The EurekaLog Developer Guide

Appendix B - Types

Use the record and callback declarations here before constructing values or writing event handlers. Field and enumeration entries follow their owning type. An internal record field list is not a stable binary ABI.

Defaults appear only where a declaration or an option description supplies them. A missing exception list is not a no-throw guarantee; use each entry's return values, requirements and remarks. A declaration does not establish thread safety or transfer ownership unless the accompanying contract says so. Internal, unstable and unimplemented surfaces remain visibly marked.

Names are grouped by declaring unit, then by type or class. Member headings retain the owner name. Cross-references to appendices A-D refer to this book; no external help is needed. Same-name declarations in different units are qualified so their contracts cannot be confused. Syntax blocks are declarations for lookup, not standalone programs.

Unit map: EBaseClasses, ECallStack, EDebugInfo, EDialog, EDisAsm, EEncrypt, EEvents, EExceptionManager, EFreeze, EHash, ELogBuilder, ELogging, EMemLeaks, EResLeaks, EScreenShot, ESend, ESignature, EThreadsManager, ETypes, EZip.

Callback name collision: both EEvents and ELogBuilder document TELEvReportGenMeth/TELEvReportGenProc. Their declarations differ (TObject versus TBaseLogBuilder, and callback parameter naming). The unit-qualified entries preserve both; use the declaration belonging to the API you register with rather than assuming interchangeability.

EBaseClasses

PELLocationInfo

A pointer to code location information.

PELLocationInfo = ^TELLocationInfo;

Remarks.

This is a reference to code location information record.

TELLocationInfo

A code location information.

TELLocationInfo = record
  Address: Pointer;
  DebugDetail: TEurekaDebugDetail;
  Offset: DWORD;
  Module: HMODULE;
  ModuleName: String;
  ModuleType: TEurekaModuleType;
  UnitName: String;
  SourceName: String;
  ClassName: String;
  ProcedureName: String;
  LineNumber: Integer;
  OffsetFromProcName: Integer;
  ProcOffsetLine: Integer;
  OffsetFromLineNumber: Integer;
  ParentProcOffsetLine: Integer;
  ParentLineNumber: Integer;
  ParentOffsetFromLineNumber: Integer;
  ParentSourceName: String;
  DebugInfo: TELDebugInfoSource;
  BinaryFileName: String;
end;

Remarks.

This record holds information about one specific code location (method, function, line, etc.).

It can be obtained by various routines from EDebugInfo unit (appendix A, GetLocationInfo).

TELLocationInfo.Address

RAW pointer.

  Address: Pointer;

Value.

Code address.

Remarks.

Absolute code address. This is the original address to code which was used to obtain information.

TELLocationInfo.BinaryFileName

Debug information file source.

  BinaryFileName: String;

Value.

Full absolute file name.

Remarks.

Name of the file from which debug information was loaded. Typically it is the same as ModuleName. It will be different if debug information was loaded from external file (such as .map, .jdbg, etc.).

TELLocationInfo.ClassName

Class name.

  ClassName: String;

Value.

Class symbol name.

Remarks.

This is class name to which method with code belongs to. It will be empty when code is not inside method.

TELLocationInfo.DebugDetail

Detalization level.

  DebugDetail: TEurekaDebugDetail;

Value.

Level of detalization.

Remarks.

Indicates level of debug info's detalization. Basically, it indicates what fields in this record are filled.

TELLocationInfo.DebugInfo

Debug information class.

  DebugInfo: TELDebugInfoSource;

Value.

Debug information class.

Remarks.

Specifies class which was used to load debug information.

TELLocationInfo.LineNumber

Line number.

  LineNumber: Integer;

Value.

Line number in source file.

Remarks.

This is number of the text line to which code belongs to.

TELLocationInfo.Module

Module.

  Module: HMODULE;

Value.

Start of the module.

Remarks.

This is the executable module (.exe, .dll, .bpl) to which code belongs to.

TELLocationInfo.ModuleName

Module name.

  ModuleName: String;

Value.

Full absolute file name.

Remarks.

This is the name of the Module.

TELLocationInfo.ModuleType

Module type.

  ModuleType: TEurekaModuleType;

Value.

Kind of the Module.

Remarks.

This indicates if Module is .exe, .dll, or .bpl.

TELLocationInfo.Offset

Module offset.

  Offset: DWORD;

Value.

= Address - Module.

Remarks.

This is offset of the Address from the start of the Module in bytes.

TELLocationInfo.OffsetFromLineNumber

Offset from line.

  OffsetFromLineNumber: Integer;

Value.

= Address - StartOfLine.

Remarks.

Offset from start of the line in bytes.

TELLocationInfo.OffsetFromProcName

Offset from procedure.

  OffsetFromProcName: Integer;

Value.

= Address - StartOfRoutine.

Remarks.

Offset from start of the routine in bytes.

TELLocationInfo.ProcedureName

Routine name.

  ProcedureName: String;

Value.

Method name when Class is not empty. Function or procedure name when Class is empty.

Remarks.

This is the name of a routine (method/function/procedure) to code belongs to.

TELLocationInfo.ProcOffsetLine

Offset from procedure (lines).

  ProcOffsetLine: Integer;

Value.

= LineOf(Address) - LineOf(StartOfRoutine).

Remarks.

Difference in line numbers between code (Address) and start of the routine.

TELLocationInfo.SourceName

Source name.

  SourceName: String;

Value.

Unit file name (not unit name!).

Remarks.

This is file name (without path) of the unit. Such as Unit1.pas.

TELLocationInfo.UnitName

Unit name.

  UnitName: String;

Value.

Unit symbol name (not file name!).

Remarks.

This is unit name to which code belongs to. Such as Unit1.

ECallStack

TEurekaCallStack

Alias for TEurekaStackListV7.

TEurekaCallStack = TEurekaStackList;

Remarks.

This is generic name, which will be changed in next EurekaLog versions. Use this name to refer the latest possible method.

Tip. This is the same as TEurekaStackList (appendix B).

TEurekaCallStackClass

Class of TEurekaBaseStackList.

TEurekaCallStackClass = class of TEurekaBaseStackList;

TEurekaStackList

Alias for TEurekaStackListV7.

TEurekaStackList = TEurekaStackListV7;

Remarks.

This is generic name, which will be changed in next EurekaLog versions. Use this name to refer the latest possible method.

Tip. This is the same as TEurekaCallStack (appendix B).

EDebugInfo

TELUseParent

Used to indicate which location information should be used for include files.

TELUseParent = (
eupNone,
eupChild,
eupParent
);

Members.

eupChild (appendix B, TELUseParent.eupChild)

Use debug information for the included file.

eupNone (appendix B, TELUseParent.eupNone)

Use debug information for the non-include file.

eupParent (appendix B, TELUseParent.eupParent)

Use debug information for the file with {$I} directive.

Remarks.

This type is used to indicate which debug information should be used when converting debug information to string.

TELUseParent.eupChild

Use debug information for the included file.

Contract unavailable: no additional public declaration, usage preconditions, or member-behavior contract is specified here. Do not infer support beyond the documented owning type and member description.

TELUseParent.eupNone

Use debug information for the non-include file.

TELUseParent.eupParent

Use debug information for the file with {$I} directive.

EDialog

TBaseDialogClass

Pointer to dialog class.

TBaseDialogClass = class of TBaseDialog;

Remarks.

This type is used to register dialog classes into global list.

EDisAsm

PInstruction

A pointer to TInstruction (appendix B).

PInstruction = ^TInstruction;

Remarks.

This is a pointer to platform-specific TInstruction (appendix B) record.

TInstruction

A CPU instruction.

TInstruction = record
  Start: PAddress;
  Next: PAddress;
  Accessible: Boolean;
  Valid: Boolean;
  PlatformSpecific: Fields;
end;

Remarks.

This platform-specific record represents single CPU instruction. Exact fields of the record depends on target CPU. Please, refer to source code of the unit for your CPU (such as EDisAsmX8632.pas, EDisAsmX8664.pas, etc.).

TInstruction.Accessible

Is instruction readable?

  Accessible: Boolean;

Value.

True - instruction's memory is accessible (readable); False - otherwise.

Remarks.

Indicates if instruction's Start (appendix B, TInstruction.Start) address is readable. You will get Access Violation exception if you try to read from Start when Accessible if False.

TInstruction.Next

Next CPU instruction.

  Next: PAddress;

Value.

Pointer to next instruction.

Remarks.

This field contains pointer to end of current CPU instruction and start of the next (following) CPU instruction.

Note. You can use this field to determinate length of CPU instruction in bytes. Just subtract Start (appendix B, TInstruction.Start) from Next.

TInstruction.PlatformSpecific

Other platform-specific fields.

  PlatformSpecific: Fields;

Value.

Exact values and meaning depend on target CPU.

Remarks.

This is not a real field. It is just substitute for other fields in this record. For example x86-32 CPU (implemented in EDisAsmX8632.pas unit) have fields like Prefix66, OpCodeSignificantByte, OperandSize, ModRMPresent, etc.

TInstruction.Start

Start of the CPU instruction.

  Start: PAddress;

Value.

Pointer to instruction's start.

Remarks.

This field contains pointer to the start of the CPU instruction. This includes any prefixes.

TInstruction.Valid

Is instruction valid?

  Valid: Boolean;

Value.

True - instruction was decoded successfully; False - unknown or invalid instruction.

Remarks.

This field indicate if CPU instruction was decoded. All platform-specific fields in TInstruction record are valid only when Valid is True.

EEncrypt

PSalt

Pointer to salt.

PSalt = ^TSalt;

Remarks.

Use InitSalt (appendix A) to obtain new random salt. Pass the obtained value to TEADeriveKey (appendix A) function or TwofishDeriveKey (appendix A) function.

Note. In cryptography, a salt is random data that is used as an additional input to a one-way function that hashes a password. The primary function of salts is to defend against dictionary attacks versus a list of password hashes and against pre-computed rainbow table attacks.

PTwofishInitVector

Pointer to IV for Twofish.

PTwofishInitVector = ^TTwofishInitVector;

Remarks.

Use TwofishInitIV (appendix A) to obtain new random initialization vector. Pass the obtained value to TwofishEncrypt (appendix A) and store it with encrypted data - to be passed into TwofishDecrypt (appendix A) later.

Note. Initialization vector (IV) is a fixed-size input to a cryptographic primitive that is typically required to be random or pseudorandom. Randomization is crucial for encryption schemes to achieve semantic security, a property whereby repeated usage of the scheme under the same key does not allow an attacker to infer relationships between segments of the encrypted message.

TEncryptBuffer

Contains an arbitrary array of bytes.

TEncryptBuffer = EWinCrypt.DATA_BLOB;

Remarks.

This is simply a combined Pointer/Size record.

pbData field points to the data buffer.

cbData field contains the size of data in pbData in bytes.

Note. Functions from EEncrypt (appendix C) unit will allocate TEncryptBuffer buffers via AllocMem function. Such allocations can be released via EncryptBufferFree (appendix A) function.

TRSAExport

Defines how to export/import RSA key.

TRSAExport = (
rsBLOB,
rsDER,
rsPEM
);

Members.

rsBLOB (appendix B, TRSAExport.rsBLOB)

Export/import in RAW BLOB with header (Microsoft PUBLICKEYBLOB/PRIVATEKEYBLOB, little-endian byte order).

rsDER (appendix B, TRSAExport.rsDER)

Export/import in RAW ASN.1-encoded form (DER), big-endian. This format corresponds to RSA_CSP_PUBLICKEYBLOB/PKCS_RSA_PRIVATE_KEY, and has NO optional header.

rsPEM (appendix B, TRSAExport.rsPEM)

Export/import in text form (PEM=base64-encoded DER).

TRSAExport.rsBLOB

Export/import in RAW BLOB with header (Microsoft PUBLICKEYBLOB/PRIVATEKEYBLOB, little-endian byte order).

TRSAExport.rsDER

Export/import in RAW ASN.1-encoded form (DER), big-endian. This format corresponds to RSA_CSP_PUBLICKEYBLOB/PKCS_RSA_PRIVATE_KEY, and has NO optional header.

TRSAExport.rsPEM

Export/import in text form (PEM = base64-encoded DER).

TRSAImport

Alias to TRSAExport.

TRSAImport = TRSAExport;

TRSAKey

Key for RSA encryption.

TRSAKey = record
  PublicKey: TEncryptBuffer;
  PrivateKey: TEncryptBuffer;
end;

Remarks.

This is private and public keys pair used for asymmetrical encryption, decryption, signing and verification by using RSA cipher.

You need to free this key after you have done working with it - by using RSADestroyKey (appendix A) function.

This key can be created by RSAGenKey (appendix A) function or be imported by RSALoadPublicKey (appendix A) and RSALoadPrivateKey (appendix A) functions. You need to be careful when handling private key part of this key. I.e. leaking private key means leaking your key.

Use RSAEncrypt (appendix A) function to encrypt (by using your public key) "clear text" data, use RSADecrypt (appendix A) function to decrypt (by using your private key) encrypted data and get "clear text" back.

Use RSASign (appendix A) function to sign (by using your private key) your data, use RSAVerify (appendix A) to verify (by using your public key) a signature.

TRSAKey.PrivateKey

Contains private key part of RSA key.

  PrivateKey: TEncryptBuffer;

Value.

RAW binary data of encrypted private key.

Remarks.

This field holds protected private key in encrypted form. The clean unencrypted/unprotected form of private key is not available.

Use RSASavePrivateKey (appendix A) function to export this value. Do not copy this value directly, as it will be unusable.

TRSAKey.PublicKey

Contains public key part of RSA key.

  PublicKey: TEncryptBuffer;

Value.

RAW binary data of public key.

Remarks.

This field holds unprotected public key in clear form.

Use RSASavePublicKey (appendix A) function to export this value or simply copy this value directly.

TRSASignature

Digital signature.

TRSASignature = TEncryptBuffer;

Remarks.

This type holds RAW bytes of RSA digital signature. This data can be freely copied or exported/imported as RAW bytes. No encoding, encryption/decryption is required.

Use SecureFree (appendix A, EEncrypt.SecureFree) function to release this type.

TSalt

Salt value for deriving key from password.

TSalt = TTEAKey;

Remarks.

Use InitSalt (appendix A) to obtain new random salt. Pass the obtained value to TEADeriveKey (appendix A) function or TwofishDeriveKey (appendix A) function.

TTEAKey

Key for TEA encryption.

TTEAKey = packed array[0..3]of Cardinal;

Remarks.

This type holds binary key which can be used for symmetrical encryption and decryption using TEA cipher.

Important. This type is also used as salt storage. See PSalt (appendix B)/TSalt (appendix B) type.

You do not need to free/release/dispose this key - it does not contain any allocated memory. However, it is strongly recommended to call TEADestroyKey (appendix A) function once you have finished working with key - to erase it with zeros.

This key is derived from string (or binary) password via TEADeriveKey (appendix A) function. You can freely export/import this key as RAW binary value, but you need to be careful - because the key have the same power as password. I.e. leaking this key means leaking your password.

Use TEAEncrypt (appendix A) function to encrypt "clear text" data, use TEADecrypt (appendix A) function to decrypt encrypted data and get "clear text" data back.

TTwofishInitVector

Initialization Vector (IV) for Twofish.

TTwofishInitVector = packed array[0..15]of Byte;

Remarks.

TTwofishKey

(Precalculated) Key for Twofish encryption.

TTwofishKey = TEncryptBuffer;

Remarks.

This is precalculated key used for symmetrical encryption and decryption by using Twofish cipher.

You need to free this key after you have done working with it - by using TwofishDestroyKey (appendix A) function.

This key can be created by TwofishDeriveKey (appendix A) function or be imported by TwofishInitKey (appendix A) function. You need to be careful when handling this key. I.e. leaking this key means leaking your key/password.

Use TwofishEncrypt (appendix A) function to encrypt "clear text" data, use TwofishDecrypt (appendix A) function to decrypt encrypted data and get "clear text" back.

TTwofishRAWKey

(RAW) Key for Twofish encryption.

TTwofishRAWKey = packed array[0..31]of Byte;

Remarks.

This is RAW binary key for Twofish. 256 bits (32 bytes).

EurekaLog uses precalculated/cached key to speed up encryption/decryption. Therefore, RAW key can not be used directly. You must first "import" it via TwofishInitKey (appendix A) function.

EEvents

TELEvAttachedFilesRequestMeth

Method event handler for OnAttachedFilesRequest event.

TELEvAttachedFilesRequestMeth = procedure(
  AExceptionInfo: TEurekaExceptionInfo;
  const ATempFolder: String;
  AAttachedFiles: TStrings;
  var ACallNextHandler: Boolean
) of object;

Parameters.

AExceptionInfo [in] — Information about exception.
ATempFolder [in] — Temp folder name with trailing path delimiter. You can use it to store any temp files. All files in this folder will be deleted automatically.
AAttachedFiles [out] — List of attached file names. Use full absolute paths.
ACallNextHandler [out] — True (default) - call next registered event handler, False - do not call next event handler.

Remarks.

You can use this event to send arbitrary files with bug report. Files will be send as separate files.

To include files into bug report file - use OnZippedFilesRequest event.

Caution!

Event handlers registered via the TEurekaLogEvents component will be active only when corresponding form is live (created). Such handlers will not be called before form is created or after it was destroyed. For this reason you may want to register your event handlers via code. For example, it would be a bad idea to use TEurekaLogEvents component for implementing your error dialog, because your dialog will not be displayed for exceptions outside form (e.g. initialization/finalization exceptions, as well as exceptions in form's constructor).

Important. Any event is called from the context of exception thread, which may be not the main thread of application. Thus, it's highly recommended to avoid using any global-like data and to avoid access VCL objects. If you still need to do any of that - please use proper thread synchronization for globals and Synchronize method for VCL access.

TELEvAttachedFilesRequestProc

Procedural event handler for OnAttachedFilesRequest event.

TELEvAttachedFilesRequestProc = procedure(
  const ACustom: Pointer;
  AExceptionInfo: TEurekaExceptionInfo;
  const ATempFolder: String;
  AAttachedFiles: TStrings;
  var ACallNextHandler: Boolean
);

Parameters.

ACustom [in, optional] — Custom user data parameter. It's the same pointer as it was passed to RegisterEvent-function.
AExceptionInfo [in] — Information about exception.
ATempFolder [in] — Temp folder name with trailing path delimiter. You can use it to store any temp files. All files in this folder will be deleted automatically.
AAttachedFiles [out] — List of attached file names. Use full absolute paths.
ACallNextHandler [out] — True (default) - call next registered event handler, False - do not call next event handler.

Remarks.

You can use this event to send arbitrary files with bug report. Files will be send as separate files.

To include files into bug report file - use OnZippedFilesRequest event.

TELEvCustomBugIDMeth

Method event handler for OnCustomBugID event.

TELEvCustomBugIDMeth = procedure(
  AExceptionInfo: TEurekaExceptionInfo;
  var ABugID, ACustomBugID: Word;
  var ACallNextHandler: Boolean
) of object;

Parameters.

AExceptionInfo [in] — Information about exception.
ABugID [in, out] — Primary BugID generated by EurekaLog.
ACustomBugID [out] — Custom BugID.
ACallNextHandler [out] — True (default) - call next registered event handler, False - do not call next event handler.

Remarks.

Use this event handler to override BugID creation.

You can define your own sub-ID by altering ACustomBugID. Alternatively you may also replace BugID generated by EurekaLog.

Caution!

TELEvCustomBugIDProc

Procedural event handler for OnCustomBugID event.

TELEvCustomBugIDProc = procedure(
  const ACustom: Pointer;
  AExceptionInfo: TEurekaExceptionInfo;
  var ABugID, ACustomBugID: Word;
  var ACallNextHandler: Boolean
);

Parameters.

ACustom [in, optional] — Custom user data parameter. It's the same pointer as it was passed to RegisterEvent-function.
AExceptionInfo [in] — Information about exception.
ABugID [in, out] — Primary BugID generated by EurekaLog.
ACustomBugID [out] — Custom BugID.
ACallNextHandler [out] — True (default) - call next registered event handler, False - do not call next event handler.

Remarks.

Use this event handler to override BugID creation.

You can define your own sub-ID by altering ACustomBugID. Alternatively you may also replace BugID generated by EurekaLog.

TELEvCustomButtonClickMeth

Method event handler for OnCustomButtonClick event.

TELEvCustomButtonClickMeth = procedure(
  AExceptionInfo: TEurekaExceptionInfo;
  ADialog: TObject;
  var ACloseDialog: Boolean;
  var ACallNextHandler: Boolean
) of object;

Parameters.

AExceptionInfo [in] — Information about exception.
AOptions [in] — Current EurekaLog options.
ADialog [in] — Current dialog class (child class of TBaseDialog).
ACloseDialog [out] — True - close dialog after return, False (default) - do not close dialog.
ACallNextHandler [out] — True (default) - call next registered event handler, False - do not call next event handler.

Remarks.

This event is invoked when end-user has clicked on custom button in error dialog. You should put your custom action code there. For example, if you setup custom button to be "check for updates" - then you should put your update checking code there.

Note. There is a similar event (appendix B, TELEvHelpButtonClickMeth).

Custom button is shown only when you specify it in options. It's shown for errors (i.e. bug reports).
Help button is shown automatically whenever there is help context for known exception (which do not generate bug report).

Caution!

TELEvCustomButtonClickProc

Procedural event handler for OnCustomButtonClick event.

TELEvCustomButtonClickProc = procedure(
  const ACustom: Pointer;
  AExceptionInfo: TEurekaExceptionInfo;
  ADialog: TObject;
  var ACloseDialog: Boolean;
  var ACallNextHandler: Boolean
);

Parameters.

ACustom [in, optional] — Custom user data parameter. It's the same pointer as it was passed to RegisterEvent-function.
AExceptionInfo [in] — Information about exception.
AOptions [in] — Current EurekaLog options.
ADialog [in] — Current dialog class.
ACloseDialog [out] — True - close dialog after return, False (default) - do not close dialog.
ACallNextHandler [out] — True (default) - call next registered event handler, False - do not call next event handler.

Remarks.

Note. There is a similar event (appendix B, TELEvHelpButtonClickProc).

Custom button is shown only when you specify it in options. It's shown for errors (i.e. bug reports).
Help button is shown automatically whenever there is help context for known exception (which do not generate bug report).

TELEvCustomDataRequestMeth

Method event handler for OnCustomDataRequest event.

TELEvCustomDataRequestMeth = procedure(
  AExceptionInfo: TEurekaExceptionInfo;
  ALogBuilder: TObject;
  ADataFields: TStrings;
  var ACallNextHandler: Boolean
) of object;

Parameters.

AExceptionInfo [in] — Information about exception.
ALogBuilder [in] — Log builder class, representing bug report.
ADataFields [out] — Custom fields to add into bug report (as name=value pairs).
ACallNextHandler [out] — True (default) - call next registered event handler, False - do not call next event handler.

Remarks.

This event is invoked before saving bug report to allow you to supply custom fields. Fields should be supplied as name=value pairs. We recommend to use the following construct: ADataFields.Values['Field-Name'] := 'Field-Value'. Field name can be arbitrary and are choosen by you.

Warning. Do not confuse custom fields (OnCustomDataRequest event) and web fields (OnCustomWebFieldsRequest event). Custom fields are inserted into bug report file. Web fields are not stored in bug report, web fields are POST-ed to bug tracker / web-site via API or HTTP request.

Caution!

TELEvCustomDataRequestProc

Procedural event handler for OnCustomDataRequest event.

TELEvCustomDataRequestProc = procedure(
  const ACustom: Pointer;
  AExceptionInfo: TEurekaExceptionInfo;
  ALogBuilder: TObject;
  ADataFields: TStrings;
  var ACallNextHandler: Boolean
);

Parameters.

ACustom [in, optional] — Custom user data parameter. It's the same pointer as it was passed to RegisterEvent-function.
AExceptionInfo [in] — Information about exception.
ALogBuilder [in] — Log builder class, representing bug report.
ADataFields [out] — Custom fields to add into bug report (as name=value pairs).
ACallNextHandler [out] — True (default) - call next registered event handler, False - do not call next event handler.

Remarks.

TELEvCustomFileNameMeth

Method event handler for OnCustomFileName event.

TELEvCustomFileNameMeth = procedure(
  AExceptionInfo: TEurekaExceptionInfo;
  const AFileType: TEurekaLogFileType;
  var AFileName: String;
  var ACallNextHandler: Boolean
) of object;

Parameters.

AExceptionInfo [in] — Information about exception.
AFileType [in] — Kind of file name to modify.
AFileName [in, out] — Actual file name that may be changed. Use full absolute file path.
ACallNextHandler [out] — True (default) - call next registered event handler, False - do not call next event handler.

Remarks.

Use this event to assign/modify file names.

Even though you can relocate file in arbitrary folder - it's highly recommended to keep original folder and extension.

Caution!

TELEvCustomFileNameProc

Procedural event handler for OnCustomFileName event.

TELEvCustomFileNameProc = procedure(
  const ACustom: Pointer;
  AExceptionInfo: TEurekaExceptionInfo;
  const AFileType: TEurekaLogFileType;
  var AFileName: String;
  var ACallNextHandler: Boolean
);

Parameters.

ACustom [in, optional] — Custom user data parameter. It's the same pointer as it was passed to RegisterEvent-function.
AExceptionInfo [in] — Information about exception.
AFileType [in] — Kind of file name to modify.
AFileName [in, out] — Actual file name that may be changed. Use full absolute file path.
ACallNextHandler [out] — True (default) - call next registered event handler, False - do not call next event handler.

Remarks.

Use this event to assign/modify file names.

Even though you can relocate file in arbitrary folder - it's highly recommended to keep original folder and extension.

TELEvCustomWebFieldsRequestMeth

Method event handler for OnCustomWebFieldsRequest event.

TELEvCustomWebFieldsRequestMeth = procedure(
  AExceptionInfo: TEurekaExceptionInfo;
  ASender: TObject;
  AWebFields: TStrings;
  var ACallNextHandler: Boolean
) of object;

Parameters.

AExceptionInfo [in, optional] — Information about exception. Can be nil.
ASender [in] — Current sender class (child class of TELUniversalSender).
AWebFields [in] — Web fields to send to web-site (as name=value pairs).
ACallNextHandler [out] — True (default) - call next registered event handler, False - do not call next event handler.

Remarks.

This event is invoked before sending to allow you to supply custom fields. Fields should be supplied as name=value pairs. We recommend to use the following construct: AWebFields.Values['Field-Name'] := 'Field-Value'. Field name depends on used send method.

For example, if you are sending to Mantis - then field name would be custom field name as it appears in Mantis configuration (e.g. like 'cf_count').

This event is not called if send method does not need / support custom fields.

Note. AExceptionInfo param will be missing if sending is performed outside of exception processing. E.g. if sending is called manually.

Important. EurekaLog will can the OnCustomWebField event only when sending a bug report. If you are invoking sender manually (for example, to send a feedback - there will be no bug report, so the OnCustomWebField event won't be called. This is done because the event handler might not expect to be called to send something other than a bug report (i.e. the AExceptionInfo param is nil), and it might crash or populate the fields incorrectly. However, if you've written a handler that can handle both error reports and feedback, you can tell EurekaLog about it by setting the _AlwaysCallCustomWebFieldsRequest global variable (from the ESendWeb unit) to True on startup of your application. If you need to distinguish between sending an error report and sending feedback in your event handler, you can pass a custom field in sending options.

Caution!

TELEvCustomWebFieldsRequestProc

Procedural event handler for OnCustomWebFieldsRequest event.

TELEvCustomWebFieldsRequestProc = procedure(
  const ACustom: Pointer;
  AExceptionInfo: TEurekaExceptionInfo;
  ASender: TObject;
  AWebFields: TStrings;
  var ACallNextHandler: Boolean
);

Parameters.

ACustom [in, optional] — Custom user data parameter. It's the same pointer as it was passed to RegisterEvent-function.
AExceptionInfo [in, optional] — Information about exception. Can be nil.
ASender [in] — Current sender class (child class of TELUniversalSender).
AWebFields [in] — Web fields to send to web-site (as name=value pairs).
ACallNextHandler [out] — True (default) - call next registered event handler, False - do not call next event handler.

Remarks.

For example, if you are sending to Mantis - then field name would be custom field name as it appears in Mantis configuration (e.g. like 'cf_count').

This event is not called if send method does not need / support custom fields.

Note. AExceptionInfo param will be missing if sending is performed outside of exception processing. E.g. if sending is called manually.

TELEvExceptionActionMeth

Method event handler for OnExceptionAction event.

TELEvExceptionActionMeth = procedure(
  AExceptionInfo: TEurekaExceptionInfo;
  const AEurekaAction: TEurekaActionType;
  const AAdditionalInfo: String;
  var AExecute: Boolean;
  var ACallNextHandler: Boolean
) of object;

Parameters.

AExceptionInfo [in, optional] — Information about exception. Can be nil.
AEurekaAction [in] — Action to perform.
AAdditionalInfo [in, optional] — Additional information about action (see remarks).
AExecute [out] — "Before-like" actions: True - (default) perform action, False - cancel/skip action;

"After-like" actions: True - action is successful, False - action was unsuccessful;

Note. This argument is ignored for atSendCancelled (appendix B, TEurekaActionType.atSendCancelled).

ACallNextHandler [out] — True (default) - call next registered event handler, False - do not call next event handler.

Tip. Set to False, if you set AExecute to False.

Remarks.

OnExceptionAction event is fired for any action with exception during exception processing: saving to bug report, sending via Internet, etc. You can use this event to alter actions, cancel/skip them, etc.

AAdditionalInfo argument holds additional information for actions. Currently this argument have non-empty value for atSending (appendix B, TEurekaActionType.atSending) and atSent (appendix B, TEurekaActionType.atSent) actions. For these actions - AAdditionalInfo argument holds send engine class name. This information is useful if you use several send methods (for example, HTTP and e-mail). the sender classes in appendix D.

For "before"-like actions: AExecute will determinate if EurekaLog should execute the action. You can use this to skip certain actions (e.g. skip sending, skip dialog, skip saving bug report, etc.).

For "after"-like actions: AExecute will determinate if EurekaLog should consider action as succeeded (or failed). You can use this to skip errors.

Note. Basically, for most actions EurekaLog follow such pattern (pseudo-code):

repeat

MakeCall := DoEventExceptionAction(... "before" ...);

try

if MakeCall then

Result := PerformAction

else

Result := Cancelled;

except

Result := UnknownError;

end;

Result := DoEventExceptionAction(... "after" ...);

if Failed(Result) then

Retry := DoEventExceptionError(...)

else

Retry := False;

until not Retry;

Caution!

TELEvExceptionActionProc

Procedural event handler for OnExceptionAction event.

TELEvExceptionActionProc = procedure(
  const ACustom: Pointer;
  AExceptionInfo: TEurekaExceptionInfo;
  const AEurekaAction: TEurekaActionType;
  const AAdditionalInfo: String;
  var AExecute: Boolean;
  var ACallNextHandler: Boolean
);

Parameters.

ACustom [in, optional] — Custom user data parameter. It's the same pointer as it was passed to RegisterEvent-function.
AExceptionInfo [in, optional] — Information about exception. Can be nil.
AEurekaAction [in] — Action to perform.
AAdditionalInfo [in, optional] — Additional information about action (see remarks).
AExecute [out] — "Before-like" actions: True - (default) perform action, False - cancel/skip action;

"After-like" actions: True - action is successful, False - action was unsuccessful;

Note. This argument is ignored for atSendCancelled (appendix B, TEurekaActionType.atSendCancelled).

ACallNextHandler [out] — True (default) - call next registered event handler, False - do not call next event handler.

Tip. Set to False, if you set AExecute to False.

Remarks.

For "before"-like actions: AExecute will determinate if EurekaLog should execute the action. You can use this to skip certain actions (e.g. skip sending, skip dialog, skip saving bug report, etc.).

For "after"-like actions: AExecute will determinate if EurekaLog should consider action as succeeded (or failed). You can use this to skip errors.

Note. Basically, for most actions EurekaLog follow such pattern (pseudo-code):

repeat

MakeCall := DoEventExceptionAction(... "before" ...);

try

if MakeCall then

Result := PerformAction

else

Result := Cancelled;

except

Result := UnknownError;

end;

Result := DoEventExceptionAction(... "after" ...);

if Failed(Result) then

Retry := DoEventExceptionError(...)

else

Retry := False;

until not Retry;

TELEvExceptionErrorMeth

Method event handler for OnExceptionError event.

TELEvExceptionErrorMeth = procedure(
  AExceptionInfo: TEurekaExceptionInfo;
  const AEurekaAction: TEurekaActionType;
  const AAdditionalInfo: String;
  var ARetry: Boolean;
  var ACallNextHandler: Boolean
) of object;

Parameters.

AExceptionInfo [in, optional] — Information about exception. Can be nil.
AEurekaAction [in] — Failed action.
AAdditionalInfo [in] — Reason why action has failed.
ARetry [out] — True - repeat failed action, False - (default) fail operation.
ACallNextHandler [out] — True (default) - call next registered event handler, False - do not call next event handler.

Tip. Set to False, if you set ARetry to True.

Remarks.

OnExceptionError event is fired for any failed operation during exception processing: saving to bug report, sending via Internet, etc. You can use this event to correct settings and retry the operation or to use a fallback fail code, etc.

AExceptionInfo represents original exception which is being processed. It may be nil.

AAdditionalInfo represents secondary error which failed AEurekaAction step.

Tip. Be sure to do something before switching ARetry to True. Repeating failed action without any attempt to correct settings / environment will simply fail again.

Warning. Be careful when setting ARetry to True: the failed action will be repeated and may raise the same error again. Ensure you have some sort of check to avoid infinite loop.

Caution!

TELEvExceptionErrorProc

Procedural event handler for OnExceptionError event.

TELEvExceptionErrorProc = procedure(
  const ACustom: Pointer;
  AExceptionInfo: TEurekaExceptionInfo;
  const AEurekaAction: TEurekaActionType;
  const AAdditionalInfo: String;
  var ARetry: Boolean;
  var ACallNextHandler: Boolean
);

Parameters.

ACustom [in, optional] — Custom user data parameter. It's the same pointer as it was passed to RegisterEvent-function.
AExceptionInfo [in, optional] — Information about exception. Can be nil.
AEurekaAction [in] — Failed action.
AAdditionalInfo [in] — Reason why action has failed.
ARetry [out] — True - repeat failed action, False - (default) fail operation.
ACallNextHandler [out] — True (default) - call next registered event handler, False - do not call next event handler.

Tip. Set to False, if you set ARetry to True.

Remarks.

AExceptionInfo represents original exception which is being processed. It may be nil.

AAdditionalInfo represents secondary error which failed AEurekaAction step.

Tip. Be sure to do something before switching ARetry to True. Repeating failed action without any attempt to correct settings / environment will simply fail again.

Warning. Be careful when setting ARetry to True: the failed action will be repeated and may raise the same error again. Ensure you have some sort of check to avoid infinite loop.

TELEvExceptionNotifyMeth

Method event handler for OnExceptionNotify event.

TELEvExceptionNotifyMeth = procedure(
  AExceptionInfo: TEurekaExceptionInfo;
  var AHandle: Boolean;
  var ACallNextHandler: Boolean
) of object;

Parameters.

AExceptionInfo [in] — Information about exception.
AHandle [out] — True - (default) process exception with EurekaLog, False - process exception with standard exception handler
ACallNextHandler [out] — True (default) - call next registered event handler, False - do not call next event handler.

Tip. Set ACallNextToHandler to False, if you set AHandle to False.

Remarks.

By default: OnExceptionNotify event is fired for any exception which wasn't handled by the code.

Note. If "Catch handled exception" option is enabled - this event will also fire for any handled exception.

You can determinate the kind of exception (handled or unhandled) by analyzing properties of AExceptionInfo argument (see Handled property).

You can use this event to disable processing of certain exceptions by EurekaLog.

Tip. You can also use exception filters (chapter 8) instead of this event.

Use OnExceptionAction (appendix B, TELEvExceptionActionProc) event to fine-control processing of exceptions.

Caution!

TELEvExceptionNotifyProc

Procedural event handler for OnExceptionNotify event.

TELEvExceptionNotifyProc = procedure(
  const ACustom: Pointer;
  AExceptionInfo: TEurekaExceptionInfo;
  var AHandle: Boolean;
  var ACallNextHandler: Boolean
);

Parameters.

ACustom [in, optional] — Custom user data parameter. It's the same pointer as it was passed to RegisterEvent-function.
AExceptionInfo [in] — Information about exception.
AHandle [out] — True - (default) process exception with EurekaLog, False - process exception with standard exception handler
ACallNextHandler [out] — True (default) - call next registered event handler, False - do not call next event handler.

Tip. Set ACallNextToHandler to False, if you set AHandle to False.

Remarks.

By default: OnExceptionNotify event is fired for any exception which wasn't handled by the code.

Note. If "Catch handled exception" option is enabled - this event will also fire for any handled exception.

You can determinate the kind of exception (handled or unhandled) by analyzing properties of AExceptionInfo argument (see Handled property).

You can use this event to disable processing of certain exceptions by EurekaLog.

Tip. You can also use exception filters (chapter 8) instead of this event.

Use OnExceptionAction (appendix B, TELEvExceptionActionProc) event to fine-control processing of exceptions.

TELEvHelpButtonClickMeth

Method event handler for OnHelpButtonClick event.

TELEvHelpButtonClickMeth = procedure(
  AExceptionInfo: TEurekaExceptionInfo;
  ADialog: TObject;
  var ACallNextHandler: Boolean
) of object;

Parameters.

AExceptionInfo [in] — Information about exception.
AOptions [in] — Current EurekaLog options.
ADialog [in] — Dialog class.
ACallNextHandler [out] — True (default) - call next registered event handler, False - do not call next event handler.

Remarks.

This event is invoked when end-user has clicked on "Help" button in error dialog.

Help button is displayed automatically for known exceptions (i.e. exceptions that are not errors; they do not generate bug reports).

Note. There is a similar event (appendix B, TELEvCustomButtonClickMeth).

Caution!

TELEvHelpButtonClickProc

Procedural event handler for OnHelpButtonClick event.

TELEvHelpButtonClickProc = procedure(
  const ACustom: Pointer;
  AExceptionInfo: TEurekaExceptionInfo;
  ADialog: TObject;
  var ACallNextHandler: Boolean
);

Parameters.

ACustom [in, optional] — Custom user data parameter. It's the same pointer as it was passed to RegisterEvent-function.
AExceptionInfo [in] — Information about exception.
AOptions [in] — Current EurekaLog options.
ADialog [in] — Dialog class.
ACallNextHandler [out] — True (default) - call next registered event handler, False - do not call next event handler.

Remarks.

This event is invoked when end-user has clicked on "Help" button in error dialog.

Help button is displayed automatically for known exceptions (i.e. exceptions that are not errors; they do not generate bug reports).

Note. There is a similar event (appendix B, TELEvCustomButtonClickProc).

TELEvPasswordRequestMeth

Method event handler for OnPasswordRequest event.

TELEvPasswordRequestMeth = procedure(
  const AModule: HMODULE;
  const APID: PGUID;
  const APasswordHash: Pointer;
  var APassword: String;
  var ACallNextHandler: Boolean
) of object;

Parameters.

AModule [in] — Module handle which password is retrieved.
APID [in, optional] — Pointer to unique project ID. Can be used to pick password from cache. This parameter is always assigned for EurekaLog 7+ modules.
APasswordHash [in, optional] — Pointer to EHash.TSHA1Hash (appendix B, TSHA1Hash). SHA1 hash of the UTF8-encoded password. Can be used to validate password. This parameter is always assigned for EurekaLog 7+ modules.
APassword [out] — Password for debug information.
ACallNextHandler [out] — True (default) - call next registered event handler, False - do not call next event handler.

Remarks.

EurekaLog includes a OnPasswordRequest event for interaction with the user program when a raised exception is handled by EurekaLog and debug information was saved as encrypted. This event allow EurekaLog to obtain the exact password required to can decrypt all the encrypted data, otherwise all the data will be store in the bug report file in encrypted form, also error dialogs will show bug report in encrypted form.

The developer of application may use EurekaLog Viewer tool to decrypt encrypted bug reports.

You can use this event to supply your password to EurekaLog. By default this password is not stored in your executables. It's impossible to decrypt encrypted debug information without a password.

You can either ask user for password at run-time or retrieve it from application's configuration.

Note. This event will not be called if password was obtained by some other means (for example, loaded from local cache, or supplied via --el_password= cmd line argument, etc.).

Caution!

TELEvPasswordRequestProc

Procedural event handler for OnPasswordRequest event.

TELEvPasswordRequestProc = procedure(
  const ACustom: Pointer;
  const AModule: HMODULE;
  const APID: PGUID;
  const APasswordHash: Pointer;
  var APassword: String;
  var ACallNextHandler: Boolean
);

Parameters.

ACustom [in, optional] — Custom user data parameter. It's the same pointer as it was passed to RegisterEvent-function.
AModule [in] — Module handle which password is retrieved.
APID [in, optional] — Pointer to unique project ID. Can be used to pick password from cache. This parameter is always assigned for EurekaLog 7+ modules.
APasswordHash [in, optional] — Pointer to EHash.TSHA1Hash (appendix B, TSHA1Hash). SHA1 hash of the UTF8-encoded password. Can be used to validate password. This parameter is always assigned for EurekaLog 7+ modules.
APassword [out] — Password for debug information.
ACallNextHandler [out] — True (default) - call next registered event handler, False - do not call next event handler.

Remarks.

The developer of application may use EurekaLog Viewer tool to decrypt encrypted bug reports.

You can use this event to supply your password to EurekaLog. By default this password is not stored in your executables. It's impossible to decrypt encrypted debug information without a password.

You can either ask user for password at run-time or retrieve it from application's configuration.

Note. This event will not be called if password was obtained by some other means (for example, loaded from local cache, or supplied via --el_password= cmd line argument, etc.).

TELEvRaiseMeth

Method event handler for OnRaise event.

TELEvRaiseMeth = procedure(
  AExceptionInfo: TEurekaExceptionInfo;
  var ACallNextHandler: Boolean
) of object;

Parameters.

AExceptionInfo [in, optional] — Information about exception. Can be nil.
ACallNextHandler [out] — True (default) - call next registered event handler, False - do not call next event handler.

Remarks.

OnRaise event is fired for each raised exception. You can use this event to collect additional information about exception, to change existing information or place any other custom logic.

Important. Do not place exception processing code into event handler for this event. Use OnExceptionNotify (appendix B, TELEvExceptionNotifyMeth) event instead.

Note. OnRaise event is invoked when EurekaLog detects that a new exception is raised. Depending on project configuration and environment - it can happen before or after an exception is actually thrown by CPU. This means that not all exception information may be collected. For example, a call stack may be nil - because building call stack for the exception requires CPU context record - which is not available until exception is actually thrown by CPU.

Note. OnRaise event is wrapped into OnActionNotify events with atCollectingExceptionInfo/atCollectedExceptionInfo.

Caution!

Any event is called from the context of exception thread, which may be not the main thread of application. Thus, it's highly recommended to avoid using any global-like data and to avoid access VCL objects. If you still need to do any of that - please use proper thread synchronization for globals and Synchronize method for VCL access.

Caution!

TELEvRaiseProc

Procedural event handler for OnRaise event.

TELEvRaiseProc = procedure(
  const ACustom: Pointer;
  AExceptionInfo: TEurekaExceptionInfo;
  var ACallNextHandler: Boolean
);

Parameters.

ACustom [in, optional] — Custom user data parameter. It's the same pointer as it was passed to RegisterEvent-function.
AExceptionInfo [in, optional] — Information about exception. Can be nil.
ACallNextHandler [out] — True (default) - call next registered event handler, False - do not call next event handler.

Remarks.

OnRaise event is fired for each raised exception. You can use this event to collect additional information about exception, to change existing information or place any other custom logic.

Important. Do not place exception processing code into event handler for this event. Use OnExceptionNotify (appendix B, TELEvExceptionNotifyProc) event instead.

Note. OnRaise event is wrapped into OnActionNotify events with atCollectingExceptionInfo/atCollectedExceptionInfo.

Caution!

EEvents.TELEvReportGenMeth

Method event handler for OnReportBeginGen/OnReportEndGen events.

TELEvReportGenMeth = procedure(
  AExceptionInfo: TEurekaExceptionInfo;
  ALogBuilder: TObject;
  var ACallNextHandler: Boolean
) of object;

Parameters.

AExceptionInfo [in] — Information about exception.
ALogBuilder [in] — Log builder class.
AOptions [in] — Current EurekaLog options.
ACallNextHandler [out] — True (default) - call next registered event handler, False - do not call next event handler.

Remarks.

This event is called before creating bug report. You can use this event to intercept creation of bug reports. The same event handler type is used for both OnReportBegtinGen and OnReportEndGen events.

ALogBuilder is TBaseLogBuilder (appendix D) instance. You need to use type cast.

Note. A more convenient case of this type (appendix B, ELogBuilder.TELEvReportGenMeth) is declared in ELogBuilder (appendix C) unit. Use it instead of this type whenever possible. Type from ELogBuilder doesn't require you to use typecast.

Caution!

EEvents.TELEvReportGenProc

Procedural event handler for OnReportBeginGen/OnReportEndGen event.

TELEvReportGenProc = procedure(
  const ACustom: Pointer;
  AExceptionInfo: TEurekaExceptionInfo;
  ALogBuilder: TObject;
  var ACallNextHandler: Boolean
);

Parameters.

ACustom [in, optional] — Custom user data parameter. It's the same pointer as it was passed to RegisterEvent-function.
AExceptionInfo [in] — Information about exception.
ALogBuilder [in] — Log builder class.
ACallNextHandler [out] — True (default) - call next registered event handler, False - do not call next event handler.

Remarks.

This event is called before creating bug report. You can use this event to intercept creation of bug reports. The same event handler type is used for both OnReportBegtinGen and OnReportEndGen events.

ALogBuilder is TBaseLogBuilder (appendix D) instance. You need to use type cast.

Note. A more convenient case of this type (appendix B, ELogBuilder.TELEvReportGenProc) is declared in ELogBuilder (appendix C) unit. Use it instead of this type whenever possible. Type from ELogBuilder doesn't require you to use typecast.

TELEvReproduceRequestMeth

Method event handler for OnReproduceRequest event.

TELEvReproduceRequestMeth = procedure(
  AExceptionInfo: TEurekaExceptionInfo;
  var AReproduceText: String;
  var ACallNextHandler: Boolean
) of object;

Parameters.

AExceptionInfo [in] — Information about exception.
AReproduceText [in, out] — Text to be used as "steps to reproduce".
ACallNextHandler [out] — True (default) - call next registered event handler, False - do not call next event handler.

Remarks.

Use this event to assign/modify "steps to reproduce". A typical example would be appending run-time information to steps to reproduce. Alternatively, you may use OnCustomData event handler.

Caution!

TELEvReproduceRequestProc

Procedural event handler for OnReproduceRequest event.

TELEvReproduceRequestProc = procedure(
  const ACustom: Pointer;
  AExceptionInfo: TEurekaExceptionInfo;
  var AReproduceText: String;
  var ACallNextHandler: Boolean
);

Parameters.

ACustom [in, optional] — Custom user data parameter. It's the same pointer as it was passed to RegisterEvent-function.
AExceptionInfo [in] — Information about exception.
AReproduceText [in, out] — Text to be used as "steps to reproduce".
ACallNextHandler [out] — True (default) - call next registered event handler, False - do not call next event handler.

Remarks.

Use this event to assign/modify "steps to reproduce". A typical example would be appending run-time information to steps to reproduce. Alternatively, you may use OnCustomData event handler.

TELEvZippedFilesRequestMeth

Method event handler for OnZippedFilesRequest event.

TELEvZippedFilesRequestMeth = procedure(
  AExceptionInfo: TEurekaExceptionInfo;
  const ATempFolder: String;
  AAttachedFiles: TStrings;
  var ACallNextHandler: Boolean
) of object;

Parameters.

AExceptionInfo [in] — Information about exception.
ATempFolder [in] — Temp folder name with trailing path delimiter. You can use it to store any temp files. All files in this folder will be deleted automatically.
AAttachedFiles [out] — List of attached file names. Use full absolute paths.
ACallNextHandler [out] — True (default) - call next registered event handler, False - do not call next event handler.

Remarks.

You can use this event to send arbitrary files with bug report. Files will be send as inside packed report (.elp file).

To include files into bug report file - use OnAttachedFilesRequest event.

Caution!

TELEvZippedFilesRequestProc

Procedural event handler for OnZippedFilesRequest event.

TELEvZippedFilesRequestProc = procedure(
  const ACustom: Pointer;
  AExceptionInfo: TEurekaExceptionInfo;
  const ATempFolder: String;
  AAttachedFiles: TStrings;
  var ACallNextHandler: Boolean
);

Parameters.

ACustom [in, optional] — Custom user data parameter. It's the same pointer as it was passed to RegisterEvent-function.
AExceptionInfo [in] — Information about exception.
ATempFolder [in] — Temp folder name with trailing path delimiter. You can use it to store any temp files. All files in this folder will be deleted automatically.
AAttachedFiles [out] — List of attached file names. Use full absolute paths.
ACallNextHandler [out] — True (default) - call next registered event handler, False - do not call next event handler.

Remarks.

You can use this event to send arbitrary files with bug report. Files will be send as inside packed report (.elp file).

To include files into bug report file - use OnAttachedFilesRequest event.

EExceptionManager

TExceptionNotifyMode

Specifies work mode of exception manager.

TExceptionNotifyMode = (
emUnknown,
emFull,
emD2009,
emHook,
emNull
);

Members.

emD2009 (appendix B, TExceptionNotifyMode.emD2009)

Extended memory manager is not set. Hi-level hook was set for Exception class. (Available only for Delphi 2009 and later, for C++ Builder 2009 and later with classic compiler; not working in C++ Builder with LLVM compiler)

emFull (appendix B, TExceptionNotifyMode.emFull)

Extended memory manager was set. Full features.

emHook (appendix B, TExceptionNotifyMode.emHook)

Extended memory manager is not set. Low-level hook was set for TObject.Destroy. May be not compatible with exe protectors ("Use Low Level Hooks" option is enabled).

emNull (appendix B, TExceptionNotifyMode.emNull)

No additional hooks. Minimal functionality. Extended memory manager is not set. Delphi/C++ Builder version is 2007 or earlier. "Use Low Level Hooks" option is disabled or not possible to hook TObject.Destroy. This includes external (non-Delphi) exceptions.

emUnknown (appendix B, TExceptionNotifyMode.emUnknown)

Work mode is not set. Exception manager was not initialized yet.

Remarks.

Work mode indicate what kind of additional hooks were installed by exception manager (appendix D, TExceptionManager). Additional hooks are required for some special features to work. This includes "Catch handled exceptions" and "Handle safecall exceptions" options.

This mode doesn't indicate state of primary hooks.

TExceptionNotifyMode.emD2009

TExceptionNotifyMode.emFull

Extended memory manager was set. Full features.

TExceptionNotifyMode.emHook

Extended memory manager is not set. Low-level hook was set for TObject.Destroy. May be not compatible with exe protectors ("Use Low Level Hooks" option is enabled).

TExceptionNotifyMode.emNull

TExceptionNotifyMode.emUnknown

Work mode is not set. Exception manager was not initialized yet.

EFreeze

TFreezeThreadClass

Class of freeze detection thread.

TFreezeThreadClass = class of TFreezeThread;

Remarks.

This type accepts TFreezeThread (appendix D) class or any of its descendants.

This type is used in FreezeThreadClass (appendix C) global variable.

Caution!

TFreezeThread is abstract class, you should not use it. Use TMainThreadFreezeDetectionThread (appendix D) or TWCTFreezeDetectionThread (appendix D) or implement your own freeze detection class.

EHash

TCRC16Hash

CRC-16 checksum.

TCRC16Hash = type Word;

Remarks.

Data type to hold CRC-16 checksum. This is 2 byte (16 bit) value (Word).

TCRC32Hash

CRC-32 checksum.

TCRC32Hash = type Cardinal;

Remarks.

Data type to hold CRC-32 checksum. This is 2 byte (16 bit) value (Word).

TMD5Hash

MD5 hash.

TMD5Hash = packed array[0..15]of Byte;

Remarks.

Data type to hold MD5 hash. This is 16 bytes (128 bits) value.

TSDBMHash

SDBM hash.

TSDBMHash = type Cardinal;

Remarks.

Data type to hold SDBM hash. This is 4 byte (32 bit) value (Cardinal).

TSHA1Hash

SHA-1 hash.

TSHA1Hash = packed array[0..19]of Byte;

Remarks.

Data type to hold SHA-1 hash. This is 20 bytes (160 bits) value.

TSHA256Hash

SHA-2/SHA-256 hash.

TSHA256Hash = packed array[0..31]of Byte;

Remarks.

Data type to hold SHA-2/SHA-256 hash. This is 32 bytes (256 bits) value.

ELogBuilder

ELogBuilder.TELEvReportGenMeth

Method event handler for OnReportBeginGen/OnReportEndGen events.

TELEvReportGenMeth = procedure(
  AExceptionInfo: TEurekaExceptionInfo;
  ALogBuilder: TBaseLogBuilder;
  var CallNextHandler: Boolean
) of object;

Parameters.

ALogBuilder [in] — Log builder class.
ACallNextHandler [out] — True (default) - call next registered event handler, False - do not call next event handler.

Remarks.

This event is called before creating bug report. You can use this event to intercept creation of bug reports. The same event handler type is used for both OnReportBegtinGen and OnReportEndGen events.

ELogBuilder.TELEvReportGenProc

Procedural event handler for OnReportBeginGen/OnReportEndGen event.

TELEvReportGenProc = procedure(
  const ACustom: Pointer;
  AExceptionInfo: TEurekaExceptionInfo;
  ALogBuilder: TBaseLogBuilder;
  var CallNextHandler: Boolean
);

Parameters.

ACustom [in, optional] — Custom user data parameter. It's the same pointer as it was passed to RegisterEvent-function.
ALogBuilder [in] — Log builder class.
ACallNextHandler [out] — True (default) - call next registered event handler, False - do not call next event handler.

Remarks.

This event is called before creating bug report. You can use this event to intercept creation of bug reports. The same event handler type is used for both OnReportBegtinGen and OnReportEndGen events.

ELogging

TLogMsgContent

Kind of data (content).

TLogMsgContent = TLogType;

Remarks.

This type specifies kind of data in the log entry (e.g. type of entry's content).

Caution!

This type is alias for TLogType (appendix B) type. However, you can only use items starting with elmc.

TLogMsgType

Kind of log entry.

TLogMsgType = TLogType;

Remarks.

This type specifies kind of single log entry.

Caution!

This type is alias for TLogType (appendix B) type. However, you can only use items starting with elmt.

TLogType

Common "type".

TLogType = (
elmtInfo,
elmtWarning,
elmtError,
elmtCheckPoint,
elmcObject,
elmcComponentAsText,
elmcStringList,
elmcText,
elmtNote,
elmtEnterMethod,
elmtExitMethod,
elmtSeparator,
elmtInactiveSeparator,
elmtClear,
elmtScratchPad,
elmtSaveLogFile,
elmcBitmap,
elmcTextFile,
elmcWindow,
elmcMemory,
elmcMemoryStatus,
elmcCustomText,
elmcCustomProperties,
elmtReminder,
elmtLevel1,
elmtLevel2,
elmtLevel3,
elmtLevel4,
elmtLevel5,
elmtLevel6,
elmtLevel7,
elmcColor,
elmcRegistry,
elmcSystemInfo,
elmcVersionInfo,
elmcXmlData,
elmcStackTrace,
elmtException,
elmcCustomTable,
elmtResetSeparator,
elmtAppStartSeparator,
elmcCollection,
elmtCollapsedMethod,
elmtExitMethodCollapse,
elmcCustomHierarchy,
elmtTiming,
elmtRed,
elmtOrange,
elmtYellow,
elmtGreen,
elmtBlue,
elmtIndigo,
elmtViolet
);

Members.

elmcBitmap (appendix B, TLogType.elmcBitmap)

[TLogMsgContent] csmBitmap

elmcCollection (appendix B, TLogType.elmcCollection)

[TLogMsgContent] csmCollection

elmcColor (appendix B, TLogType.elmcColor)

[TLogMsgContent] csmColor

elmcComponentAsText (appendix B, TLogType.elmcComponentAsText)

[TLogMsgContent] csmComponentAsText

elmcCustomHierarchy (appendix B, TLogType.elmcCustomHierarchy)

[TLogMsgContent] csmCustomHierarchy

elmcCustomProperties (appendix B, TLogType.elmcCustomProperties)

[TLogMsgContent] csmCustomProperties

elmcCustomTable (appendix B, TLogType.elmcCustomTable)

[TLogMsgContent] csmCustomTable

elmcCustomText (appendix B, TLogType.elmcCustomText)

[TLogMsgContent] csmCustomText

elmcMemory (appendix B, TLogType.elmcMemory)

[TLogMsgContent] csmMemory

elmcMemoryStatus (appendix B, TLogType.elmcMemoryStatus)

[TLogMsgContent] csmMemoryStatus

elmcObject (appendix B, TLogType.elmcObject)

[TLogMsgContent] csmObject

elmcRegistry (appendix B, TLogType.elmcRegistry)

[TLogMsgContent] csmRegistry

elmcStackTrace (appendix B, TLogType.elmcStackTrace)

[TLogMsgContent] csmStackTrace

elmcStringList (appendix B, TLogType.elmcStringList)

[TLogMsgContent] csmStringList

elmcSystemInfo (appendix B, TLogType.elmcSystemInfo)

[TLogMsgContent] csmSystemInfo

elmcText (appendix B, TLogType.elmcText)

[TLogMsgContent] csmText

elmcTextFile (appendix B, TLogType.elmcTextFile)

[TLogMsgContent] csmTextFile

elmcVersionInfo (appendix B, TLogType.elmcVersionInfo)

[TLogMsgContent] csmVersionInfo

elmcWindow (appendix B, TLogType.elmcWindow)

[TLogMsgContent] csmWindow

elmcXmlData (appendix B, TLogType.elmcXmlData)

[TLogMsgContent] csmXmlData

elmtAppStartSeparator (appendix B, TLogType.elmtAppStartSeparator)

[TLogMsgType] csmAppStartSeparator

elmtBlue (appendix B, TLogType.elmtBlue)

[TLogMsgType] csmBlue

elmtCheckPoint (appendix B, TLogType.elmtCheckPoint)

[TLogMsgType] csmCheckPoint

elmtClear (appendix B, TLogType.elmtClear)

[TLogMsgType] csmClear

elmtCollapsedMethod (appendix B, TLogType.elmtCollapsedMethod)

[TLogMsgType] csmCollapsedMethod

elmtEnterMethod (appendix B, TLogType.elmtEnterMethod)

[TLogMsgType] csmEnterMethod

elmtError (appendix B, TLogType.elmtError)

[TLogMsgType] csmError

elmtException (appendix B, TLogType.elmtException)

[TLogMsgType] csmException

elmtExitMethod (appendix B, TLogType.elmtExitMethod)

[TLogMsgType] csmExitMethod

elmtExitMethodCollapse (appendix B, TLogType.elmtExitMethodCollapse)

[TLogMsgType] csmExitMethodCollapse

elmtGreen (appendix B, TLogType.elmtGreen)

[TLogMsgType] csmGreen

elmtInactiveSeparator (appendix B, TLogType.elmtInactiveSeparator)

[TLogMsgType] csmInactiveSeparator

elmtIndigo (appendix B, TLogType.elmtIndigo)

[TLogMsgType] csmIndigo

elmtInfo (appendix B, TLogType.elmtInfo)

[TLogMsgType] csmInfo

elmtLevel1 (appendix B, TLogType.elmtLevel1)

[TLogMsgType] csmLevel1

elmtLevel2 (appendix B, TLogType.elmtLevel2)

[TLogMsgType] csmLevel2

elmtLevel3 (appendix B, TLogType.elmtLevel3)

[TLogMsgType] csmLevel3

elmtLevel4 (appendix B, TLogType.elmtLevel4)

[TLogMsgType] csmLevel4

elmtLevel5 (appendix B, TLogType.elmtLevel5)

[TLogMsgType] csmLevel5

elmtLevel6 (appendix B, TLogType.elmtLevel6)

[TLogMsgType] csmLevel6

elmtLevel7 (appendix B, TLogType.elmtLevel7)

[TLogMsgType] csmLevel7

elmtNote (appendix B, TLogType.elmtNote)

[TLogMsgType] csmNote

elmtOrange (appendix B, TLogType.elmtOrange)

[TLogMsgType] csmOrange

elmtRed (appendix B, TLogType.elmtRed)

[TLogMsgType] csmRed

elmtReminder (appendix B, TLogType.elmtReminder)

[TLogMsgType] csmReminder

elmtResetSeparator (appendix B, TLogType.elmtResetSeparator)

[TLogMsgType] csmResetSeparator

elmtSaveLogFile (appendix B, TLogType.elmtSaveLogFile)

[TLogMsgType] csmSaveLogFile

elmtScratchPad (appendix B, TLogType.elmtScratchPad)

[TLogMsgType] csmScratchPad

elmtSeparator (appendix B, TLogType.elmtSeparator)

[TLogMsgType] csmSeparator

elmtTiming (appendix B, TLogType.elmtTiming)

[TLogMsgType] csmTiming

elmtViolet (appendix B, TLogType.elmtViolet)

[TLogMsgType] csmViolet

elmtWarning (appendix B, TLogType.elmtWarning)

[TLogMsgType] csmWarning

elmtYellow (appendix B, TLogType.elmtYellow)

[TLogMsgType] csmYellow

Remarks.

This type is a base type for all "types" and "kinds" in the log file. It is compatible with CodeSite's csmXYZ consts from CodeSiteMsgTypes.inc unit.

TLogType.elmcBitmap

[TLogMsgContent] csmBitmap

TLogType.elmcCollection

[TLogMsgContent] csmCollection

TLogType.elmcColor

[TLogMsgContent] csmColor

TLogType.elmcComponentAsText

[TLogMsgContent] csmComponentAsText

TLogType.elmcCustomHierarchy

[TLogMsgContent] csmCustomHierarchy

TLogType.elmcCustomProperties

[TLogMsgContent] csmCustomProperties

TLogType.elmcCustomTable

[TLogMsgContent] csmCustomTable

TLogType.elmcCustomText

[TLogMsgContent] csmCustomText

TLogType.elmcMemory

[TLogMsgContent] csmMemory

TLogType.elmcMemoryStatus

[TLogMsgContent] csmMemoryStatus

TLogType.elmcObject

[TLogMsgContent] csmObject

TLogType.elmcRegistry

[TLogMsgContent] csmRegistry

TLogType.elmcStackTrace

[TLogMsgContent] csmStackTrace

TLogType.elmcStringList

[TLogMsgContent] csmStringList

TLogType.elmcSystemInfo

[TLogMsgContent] csmSystemInfo

TLogType.elmcText

[TLogMsgContent] csmText

TLogType.elmcTextFile

[TLogMsgContent] csmTextFile

TLogType.elmcVersionInfo

[TLogMsgContent] csmVersionInfo

TLogType.elmcWindow

[TLogMsgContent] csmWindow

TLogType.elmcXmlData

[TLogMsgContent] csmXmlData

TLogType.elmtAppStartSeparator

[TLogMsgType] csmAppStartSeparator

TLogType.elmtBlue

[TLogMsgType] csmBlue

TLogType.elmtCheckPoint

[TLogMsgType] csmCheckPoint

TLogType.elmtClear

[TLogMsgType] csmClear

TLogType.elmtCollapsedMethod

[TLogMsgType] csmCollapsedMethod

TLogType.elmtEnterMethod

[TLogMsgType] csmEnterMethod

TLogType.elmtError

[TLogMsgType] csmError

TLogType.elmtException

[TLogMsgType] csmException

TLogType.elmtExitMethod

[TLogMsgType] csmExitMethod

TLogType.elmtExitMethodCollapse

[TLogMsgType] csmExitMethodCollapse

TLogType.elmtGreen

[TLogMsgType] csmGreen

TLogType.elmtInactiveSeparator

[TLogMsgType] csmInactiveSeparator

TLogType.elmtIndigo

[TLogMsgType] csmIndigo

TLogType.elmtInfo

[TLogMsgType] csmInfo

TLogType.elmtLevel1

[TLogMsgType] csmLevel1

TLogType.elmtLevel2

[TLogMsgType] csmLevel2

TLogType.elmtLevel3

[TLogMsgType] csmLevel3

TLogType.elmtLevel4

[TLogMsgType] csmLevel4

TLogType.elmtLevel5

[TLogMsgType] csmLevel5

TLogType.elmtLevel6

[TLogMsgType] csmLevel6

TLogType.elmtLevel7

[TLogMsgType] csmLevel7

TLogType.elmtNote

[TLogMsgType] csmNote

TLogType.elmtOrange

[TLogMsgType] csmOrange

TLogType.elmtRed

[TLogMsgType] csmRed

TLogType.elmtReminder

[TLogMsgType] csmReminder

TLogType.elmtResetSeparator

[TLogMsgType] csmResetSeparator

TLogType.elmtSaveLogFile

[TLogMsgType] csmSaveLogFile

TLogType.elmtScratchPad

[TLogMsgType] csmScratchPad

TLogType.elmtSeparator

[TLogMsgType] csmSeparator

TLogType.elmtTiming

[TLogMsgType] csmTiming

TLogType.elmtViolet

[TLogMsgType] csmViolet

TLogType.elmtWarning

[TLogMsgType] csmWarning

TLogType.elmtYellow

[TLogMsgType] csmYellow

EMemLeaks

TDumpCompareFunc

Comparator for memory blocks.

TDumpCompareFunc = function(
  const AL, AR: PPointerRecord
): Integer;

Parameters.

AL [in] — A pointer to internal undocumented PPointerRecord.
AR [in] — A pointer to internal undocumented PPointerRecord.

Return value.

Return:

0: memory blocks are equal;
0: AR is greater than AL;
< 0: AL is greater than AR.

Remarks.

This type is used to define sort order for DumpAllocationsToFile (appendix A) function.

TDumpFilterFunc

Filter for memory blocks.

TDumpFilterFunc = function(
  const ABlock: PPointerRecord
): Boolean;

Parameters.

ABlock [in] — A pointer to internal undocumented PPointerRecord.

Return value.

True - if ABlock should be included in the report, False - otherwise.

Remarks.

This type is used to filter memory blocks for DumpAllocationsToFile (appendix A) function.

EResLeaks

TCheckType

Function check kind.

TCheckType = (
ctNone,
ctEqual,
ctNotEqual,
ctHResult,
ctNTStatus,
ctGetLastError
);

Members.

ctEqual (appendix B, TCheckType.ctEqual)

Function fails if return value equals to CheckValue

ctGetLastError (appendix B, TCheckType.ctGetLastError)

Function fails if return value equals to CheckValue and GetLastError returns value other than ERROR_SUCCESS

ctHResult (appendix B, TCheckType.ctHResult)

Function returns standard HResult value

ctNone (appendix B, TCheckType.ctNone)

Function always successful

ctNotEqual (appendix B, TCheckType.ctNotEqual)

Function fails if return value wasn't equal to CheckValue

ctNTStatus (appendix B, TCheckType.ctNTStatus)

Function returns standard NTSTATUS value

Remarks.

This type specifies how to determinate if function call was successful or not. This type is used by HookWin32API (appendix A) function.

TCheckType.ctEqual

Function fails if return value equals to CheckValue

TCheckType.ctGetLastError

Function fails if return value equals to CheckValue and GetLastError returns value other than ERROR_SUCCESS

TCheckType.ctHResult

Function returns standard HResult value

TCheckType.ctNone

Function always successful

TCheckType.ctNotEqual

Function fails if return value wasn't equal to CheckValue

TCheckType.ctNTStatus

Function returns standard NTSTATUS value

EScreenShot

TScreeenshotHandle

Screenshot descriptor.

TScreeenshotHandle = type Pointer;

Remarks.

This value is created by a call to the ScreenshotInit (appendix A) routine and must be released by a call to the ScreenshotFree (appendix A) routine.

It can also be passed to the ScreenshotSave (appendix A) routine.

ESend

TELUniversalSenderClass

Pointer to send method class.

TELUniversalSenderClass = class of TELUniversalSender;

Remarks.

This type is used to register send method classes into global list.

ESignature

TCertificateInfo

Certificate information.

TCertificateInfo = record
  Version: DWORD;
  Serial: String;
  Hash: String;
  Encryption: String;
  Subject: String;
  SubjectID: String;
  Issuer: String;
  IssuerID: String;
  NotBefore: TDateTime;
  NotAfter: TDateTime;
end;

Remarks.

This record contains information about digital certificate.

TCertificateInfo.Encryption

Encryption alg identifier.

  Encryption: String;

Value.

OID (object identifier) of the used algorythm.

Remarks.

This field contains ID of the used encryption/signing algoryth.

TCertificateInfo.Hash

Hash alg identifier.

  Hash: String;

Value.

OID (object identifier) of the used algorythm.

Remarks.

This field contains ID of the used hashing algoryth.

TCertificateInfo.Issuer

Issuer of certificate.

  Issuer: String;

Value.

Human-readable issuer name.

Remarks.

This field contains name of certificate authority which created (issued) the certificate.

TCertificateInfo.IssuerID

Unique issuer ID.

  IssuerID: String;

Value.

Human-readable hex representation of issuer ID.

Remarks.

This field contains unique ID for issuer. ID is arbitrary data which can identefy issuer. Hash is often used as ID.

This field is often not specified.

TCertificateInfo.NotAfter

Ending date for certificate.

  NotAfter: TDateTime;

Value.

Date and time after which the certificate is not valid.

Remarks.

This field contains date and time after which the certificate is not valid. The time part is usually 23:59:59, which means ends of the day. E.g. start of the next day is not valid.

This field is only precise to seconds.

TCertificateInfo.NotBefore

Starting date for certificate.

  NotBefore: TDateTime;

Value.

Date and time before which the certificate is not valid.

Remarks.

This field contains date and time before which the certificate is not valid. The time part is usually zero, which means start of the day.

This field is only precise to seconds.

TCertificateInfo.Serial

Serial number of certificate.

  Serial: String;

Value.

Human-readable hex-representation of serial number.

Remarks.

This field contains serial number of the certificate that contains the public key.

The serial unique identifies the certificate.

TCertificateInfo.Subject

Subject name.

  Subject: String;

Value.

Human-readable name of the subject.

Remarks.

This field contains name of the certificate.

TCertificateInfo.SubjectID

Unique subject ID.

  SubjectID: String;

Value.

Human-readable hex represenation of subject ID.

Remarks.

This field contains unique ID for subject. ID is arbitrary data which can identefy subject. Hash is often used as ID.

This field is often not specified.

TCertificateInfo.Version

Version of certificate.

  Version: DWORD;

Value.

Integer version.

Remarks.

Currently this can be 1 for CERT_V1, 2 for CERT_V2 or 3 for CERT_V3. 3 is most common.

TSignatureInfo

Information about digital signature of executable file.

TSignatureInfo = record
  FileName: String;
  Signed: Boolean;
  Verified: Boolean;
  Status: String;
  ProgramName: String;
  PublisherLink: String;
  MoreInfoLink: String;
  Certificates: array of TCertificateInfo;
  Timestamped: Boolean;
  Timestamp: TDateTime;
  TimestampCertificates: array of TCertificateInfo;
end;

Remarks.

This record contains information about digital signature (and its certificates) of executable file passed to SignatureGetInfo (appendix A) function.

FileName (appendix B, TSignatureInfo.FileName) and Signed (appendix B, TSignatureInfo.Signed) fields are always valid. All other fields are valid only if Signed (appendix B, TSignatureInfo.Signed) field is True. Additionally, Timestamp (appendix B, TSignatureInfo.Timestamp) and TimestampCertificate fields are valid only if Timestamped (appendix B, TSignatureInfo.Timestamped) field is True.

TSignatureInfo.Certificates

Signature's digital certificate.

  Certificates: array of TCertificateInfo;

Value.

Information about digital certificate which was used to create digital signature.

Remarks.

This field contains information about digital certificate which was used to create digital signature.

This field is valid only if Signed (appendix B, TSignatureInfo.Signed) field is True.

TSignatureInfo.FileName

Original file name of executable.

  FileName: String;

Value.

Executable file name.

Remarks.

This is the same value as AFileName argument passed to SignatureGetInfo (appendix A). This field is always valid.

TSignatureInfo.MoreInfoLink

Additional link.

  MoreInfoLink: String;

Value.

Human-readable link.

Remarks.

This field contains additional link.

This field may be empty, but it is often specified.

This field is valid only if Signed (appendix B, TSignatureInfo.Signed) field is True.

TSignatureInfo.ProgramName

Program name.

  ProgramName: String;

Value.

Human-readable name.

Remarks.

This field contains name which was used to sign executable.

This field is valid only if Signed (appendix B, TSignatureInfo.Signed) field is True.

TSignatureInfo.PublisherLink

Publisher link.

  PublisherLink: String;

Value.

Human-readable link.

Remarks.

This field contains link defined by publisher.

This field is usually empty.

This field is valid only if Signed (appendix B, TSignatureInfo.Signed) field is True.

TSignatureInfo.Signed

Indicate if file has digital signature.

  Signed: Boolean;

Value.

True - executable file is signed (has digital signature); False - file is not signed.

Remarks.

This field is always valid.

All other fields (except FileName (appendix B, TSignatureInfo.FileName)) are valid only if this field is True. If Signed is False then other fields (except FileName (appendix B, TSignatureInfo.FileName)) are empty.

Please note Signed = True does not mean the file's signature is valid. It simply means the file has digital signature. But it can be valid (verified) or broken. You can get status of the signature (when a file has one) from the Verified and Status fields.

TSignatureInfo.Status

Status of the digital signature.

  Status: String;

Value.

'Verified' when signature is valid. Or something like 'TRUST_E_BAD_DIGEST: The digital signature is present, but did not verify (is broken - does not match the file)' when signature is not valid.

Remarks.

This field is valid only when the Signed field is True.

You can get a simple yes/no answer from the Verified field. The Status field contain extended reason for failed signature check.

TSignatureInfo.Timestamp

Timestamp.

  Timestamp: TDateTime;

Value.

Date and time of timestamp.

Remarks.

This field contains date and time when executable was signed. The value must lie between NotBefore and NotAfter fields of Certificate field.

This field is valid only if Timestamped (appendix B, TSignatureInfo.Timestamped) field is True.

TSignatureInfo.TimestampCertificates

Certificate used to sign timestamp.

  TimestampCertificates: array of TCertificateInfo;

Value.

Information about certificate which was used to counter-sign the timestamp value.

Remarks.

This field stores certificate which was used to counter-sign timestamp value. This certificate is different from certificate for digital signature (stored in Certificate field). This is certificate of timestamping service and it does not belong to the publisher (developer) of executable file.

The timestamp itself (date/time) is stored in Timestamp (appendix B, TSignatureInfo.Timestamp) field.

TSignatureInfo.Timestamped

Indicate if signature is timestamped.

  Timestamped: Boolean;

Value.

True - digital signature was timestamped; False - digital signature has no timestamp.

Remarks.

This field is valid only if Signed (appendix B, TSignatureInfo.Signed) field is True.

If this field is True, then Timestamp (appendix B, TSignatureInfo.Timestamp) field and TimestampCertificate are also valid. Otherwise (Timestamped is False) Timestamp (appendix B, TSignatureInfo.Timestamp) and TimestampCertificate fields are zero.

TSignatureInfo.Verified

Indicate file's digital signature was verified.

  Verified: Boolean;

Value.

True - executable file is signed, and its digital signature is valid and was verified; False - file is not signed, or its digital signature is broken.

Remarks.

This field is valid only when the Signed field is True.

When Verified = False, you can get reason for failed check from the Status field.

EThreadsManager

TThreadKind

Indicates thread kind.

TThreadKind = (
tkUnknown,
tkGeneric,
tkBeginThread,
tkBeginThreadEx,
tkTThread,
tkTThreadEx
);

Members.

tkBeginThread (appendix B, TThreadKind.tkBeginThread)

RTL thread (created with BeginThread)

tkBeginThreadEx (appendix B, TThreadKind.tkBeginThreadEx)

RTL thread (created with BeginThreadEx function)

tkGeneric (appendix B, TThreadKind.tkGeneric)

Windows thread (created with CreateThread)

tkTThread (appendix B, TThreadKind.tkTThread)

RTL thread (created with TThread's descendant)

tkTThreadEx (appendix B, TThreadKind.tkTThreadEx)

RTL thread (created with TThreadEx class)

Remarks.

This type is used to specify thread kind in TEurekaThreadData class (see Kind property).

TThreadKind.tkBeginThread

RTL thread (created with BeginThread)

TThreadKind.tkBeginThreadEx

RTL thread (created with BeginThreadEx function)

TThreadKind.tkGeneric

Windows thread (created with CreateThread)

TThreadKind.tkTThread

RTL thread (created with TThread's descendant)

TThreadKind.tkTThreadEx

RTL thread (created with TThreadEx class)

ETypes

PCustomName

Defines buffer for storing name of memory block.

PCustomName = ^TCustomName;

Remarks.

This is a pointer to TCustomName type.

PPointerRecord

A pointer to TPointerRecord type.

PPointerRecord = ^TPointerRecord;

Remarks.

This is a pointer to TPointerRecord record.

Warning. This data type is subject to change. Consider it to be undocumented.

PtrUInt

Unsigned integer type with same size as Pointer.

PtrUInt = NativeUInt;

Remarks.

PtrUInt is an unsigned integer type which has always the same size as a pointer. When using integers which will be cast to pointers and vice versa, use this type, never the regular Cardinal or Integer types.

EurekaLog introduces this type, because NativeUInt has wrong size in old IDE versions.

TAppType

Defines application type.

TAppType = String;

Remarks.

This can be arbitrary string.

ETypes unit contains some predefined types - see ETypes.atXYZ constants.

TBlockType

Defines type of memory block.

TBlockType = (
btData,
btObject,
btCppObject,
btString,
btDynArray
);

Members.

btCppObject (appendix B, TBlockType.btCppObject)

The block is an instance of C++ object class.

btData (appendix B, TBlockType.btData)

RAW memory block. This value is used when EurekaLog is not able to suggest more specific block type. Pointers, dynamically allocated records, buffers - are examples of such data.

btDynArray (appendix B, TBlockType.btDynArray)

The block is a dynamic array.

btObject (appendix B, TBlockType.btObject)

The block is an instance of TObject or descendant class.

btString (appendix B, TBlockType.btString)

The block is a string. It can be ANSI or unicode string.

Remarks.

This type is used to define type of memory block in several event handlers.

TBlockType.btCppObject

The block is an instance of C++ object class.

TBlockType.btData

RAW memory block. This value is used when EurekaLog is not able to suggest more specific block type. Pointers, dynamically allocated records, buffers - are examples of such data.

TBlockType.btDynArray

The block is a dynamic array.

TBlockType.btObject

The block is an instance of TObject or descendant class.

TBlockType.btString

The block is a string. It can be ANSI or unicode string.

TBugID

BugID type.

TBugID = LongWord;

Remarks.

Current version of EurekaLog uses 4 bytes integer as BugID. The high 2 bytes are used as CRC value of string which identifies exception (chapter 8). Lower 2 bytes are not used by EurekaLog and they are left for your own usage.

TCustomName

Defines buffer for storing name of memory block.

TCustomName = array[0..59]of AnsiChar;

Remarks.

This data type is used internally in EurekaLog to store name of each memory block. This type is used to define buffer for storing name inside memory block header. It is used only when memory leaks checking are enabled. Otherwise header will not contain name field.

You can name any memory block via MemLeaksName (appendix A) function.

You can change size of this buffer if you have Enterprise version of EurekaLog. Alter the type's description and recompile EurekaLog.

TEurekaActionType

Action kind for exception processing.

TEurekaActionType = (
atEurekaLogInitializing,
atEurekaLogInitialized,
atCollectingExceptionInfo,
atCollectedExceptionInfo,
atExceptionHandling,
atShowingExceptionInfo,
atShowedExceptionInfo,
atSavingLogFile,
atSavedLogFile,
atSending,
atSent,
atSendCancelled,
atExceptionHandled,
atTerminating,
atRestarting,
atEventHandler,
atGeneral
);

Members.

atCollectedExceptionInfo (appendix B, TEurekaActionType.atCollectedExceptionInfo)

[after] Fired after collecting information about exception (building call stack)

atCollectingExceptionInfo (appendix B, TEurekaActionType.atCollectingExceptionInfo)

[before] Fired before collecting information about exception (building call stack)

atEurekaLogInitialized (appendix B, TEurekaActionType.atEurekaLogInitialized)

[after] Fired immediately after EurekaLog was initialized (ExceptionLog7 unit). Exception info will be nil. CurrentEurekaLogOptions will be available.

atEurekaLogInitializing (appendix B, TEurekaActionType.atEurekaLogInitializing)

[before] Fired before EurekaLog initializes (ExceptionLog7 unit). Exception info will be nil. Do not access CurrentEurekaLogOptions from event handler

atEventHandler (appendix B, TEurekaActionType.atEventHandler)

[after] Used only in OnExceptionError event - when user event handler raises exception; Retry is ignored

atExceptionHandled (appendix B, TEurekaActionType.atExceptionHandled)

[after] Fired after processing exception

atExceptionHandling (appendix B, TEurekaActionType.atExceptionHandling)

[before] Fired before processing exception

atGeneral (appendix B, TEurekaActionType.atGeneral)

[after] Used only in OnExceptionError event - when exception processing fails; Retry is ignored

atRestarting (appendix B, TEurekaActionType.atRestarting)

[before] Fired before application restarting

atSavedLogFile (appendix B, TEurekaActionType.atSavedLogFile)

[after] Fired after saving to bug report

atSavingLogFile (appendix B, TEurekaActionType.atSavingLogFile)

[before] Fired before saving to bug report

atSendCancelled (appendix B, TEurekaActionType.atSendCancelled)

[notify] Fired when sending was cancelled

atSending (appendix B, TEurekaActionType.atSending)

[before] Fired before sending bug report

atSent (appendix B, TEurekaActionType.atSent)

[after] Fired after sending bug report

atShowedExceptionInfo (appendix B, TEurekaActionType.atShowedExceptionInfo)

[after] Fired after showing error dialog

atShowingExceptionInfo (appendix B, TEurekaActionType.atShowingExceptionInfo)

[before] Fired before showing error dialog

atTerminating (appendix B, TEurekaActionType.atTerminating)

[before] Fired before application termination

Remarks.

This is type of action which is used in OnExceptionAction (appendix B, TELEvExceptionActionMeth) event.

Most events can be divided into 2 groups:

"Before-like" actions, which are fired before event;
"After-like" actions, which are fired after event;

Those groups have different meaning in event handler with respect to AExecute argument.

"Before-like" actions: AExecute can allow or deny action;
"After-like" actions: AExecute sets execution status - success or not;

Basically, for most actions EurekaLog follow such pattern (pseudo-code):

repeat

MakeCall := DoEventExceptionAction(... "before" ...);

if MakeCall then

Result := PerformAction

else

Result := Cancelled;

Result := DoEventExceptionAction(... "after" ...);

if Failed(Result) then

Retry := DoEventExceptionError(...)

else

Retry := False;

until not Retry;

TEurekaActionType.atCollectedExceptionInfo

[after] Fired after collecting information about exception (building call stack)

TEurekaActionType.atCollectingExceptionInfo

[before] Fired before collecting information about exception (building call stack)

TEurekaActionType.atEurekaLogInitialized

[after] Fired immediately after EurekaLog was initialized (ExceptionLog7 unit). Exception info will be nil. CurrentEurekaLogOptions will be available.

TEurekaActionType.atEurekaLogInitializing

[before] Fired before EurekaLog initializes (ExceptionLog7 unit). Exception info will be nil. Do not access CurrentEurekaLogOptions from event handler

TEurekaActionType.atEventHandler

[after] Used only in OnExceptionError event - when user event handler raises exception; Retry is ignored

TEurekaActionType.atExceptionHandled

TEurekaActionType.atExceptionHandling

TEurekaActionType.atGeneral

[after] Used only in OnExceptionError event - when exception processing fails; Retry is ignored

TEurekaActionType.atRestarting

[before] Fired before application restarting

TEurekaActionType.atSavedLogFile

[after] Fired after saving to bug report

TEurekaActionType.atSavingLogFile

[before] Fired before saving to bug report

TEurekaActionType.atSendCancelled

[notify] Fired when sending was cancelled

TEurekaActionType.atSending

[before] Fired before sending bug report

TEurekaActionType.atSent

[after] Fired after sending bug report

TEurekaActionType.atShowedExceptionInfo

[after] Fired after showing error dialog

TEurekaActionType.atShowingExceptionInfo

[before] Fired before showing error dialog

TEurekaActionType.atTerminating

[before] Fired before application termination

TEurekaDebugDetail

Level of detalization.

TEurekaDebugDetail = (
ddNone,
ddModule,
ddUnit,
ddProcedure,
ddSourceCode
);

Members.

ddModule (appendix B, TEurekaDebugDetail.ddModule)

Code belongs to module, but module does not have debug information, or code lies outside of debug information scope. Only module info is available.

ddNone (appendix B, TEurekaDebugDetail.ddNone)

No debug information is available.

ddProcedure (appendix B, TEurekaDebugDetail.ddProcedure)

Routine name is available.

ddSourceCode (appendix B, TEurekaDebugDetail.ddSourceCode)

Line number is available.

ddUnit (appendix B, TEurekaDebugDetail.ddUnit)

Unit name is available.

Remarks.

Indicates what fields are filled in code location information.

TEurekaDebugDetail.ddModule

Code belongs to module, but module does not have debug information, or code lies outside of debug information scope. Only module info is available.

TEurekaDebugDetail.ddNone

No debug information is available.

TEurekaDebugDetail.ddProcedure

Routine name is available.

TEurekaDebugDetail.ddSourceCode

Line number is available.

TEurekaDebugDetail.ddUnit

Unit name is available.

TEurekaDebugDetails

Set of detalization levels.

TEurekaDebugDetails = set of TEurekaDebugDetail;

Remarks.

Indicates what detalization levels should be used.

TEurekaLogFileType

Type of file name.

TEurekaLogFileType = (
ftSavedBugReport,
ftBugReport,
ftZIP,
ftZIPCopy,
ftXML,
ftScreenshot,
ftHTMLPage,
ftMiniDump,
ftLog
);

Members.

ftBugReport (appendix B, TEurekaLogFileType.ftBugReport)

Actual working copy of bug report. This bug report will be used for sending (.el). Default location is the sub-folder in the TEMP folder.

ftHTMLPage (appendix B, TEurekaLogFileType.ftHTMLPage)

HTML page file name (.htm, .html). Default location is the sub-folder in the TEMP folder.

ftLog (appendix B, TEurekaLogFileType.ftLog)

Log file name (.csl). Default location is the sub-folder in the TEMP folder.

ftMiniDump (appendix B, TEurekaLogFileType.ftMiniDump)

Minidump file name (.mdmp). Default location is the sub-folder in the TEMP folder.

ftSavedBugReport (appendix B, TEurekaLogFileType.ftSavedBugReport)

Saved bug report in its final location (as set in options). E.g. local bug report (.el). Default is the sub-folder in the APPDATA folder. Can be customized in EurekaLog project options. If local bug report is disabled in options, then this value defaults to the sub-folder in the TEMP folder.

ftScreenshot (appendix B, TEurekaLogFileType.ftScreenshot)

Screenshot file name (.png). Default location is the sub-folder in the TEMP folder.

ftXML (appendix B, TEurekaLogFileType.ftXML)

Name of XML bug report (.elx). Default location is the sub-folder in the TEMP folder.

ftZIP (appendix B, TEurekaLogFileType.ftZIP)

Packed bug report for sending (ZIP/ELP, including additional files, screenshot, etc.) (.elp). Default location is the sub-folder in the TEMP folder.

ftZIPCopy (appendix B, TEurekaLogFileType.ftZIPCopy)

File name for "Save copy in case of send failure" option (.elp). Default location is the My Documents folder.

Remarks.

This type is used in OnCustomFileName event handlers to specify kind of file name to modify.

TEurekaLogFileType.ftBugReport

Actual working copy of bug report. This bug report will be used for sending (.el). Default location is the sub-folder in the TEMP folder.

TEurekaLogFileType.ftHTMLPage

HTML page file name (.htm, .html). Default location is the sub-folder in the TEMP folder.

TEurekaLogFileType.ftLog

Log file name (.csl). Default location is the sub-folder in the TEMP folder.

TEurekaLogFileType.ftMiniDump

Minidump file name (.mdmp). Default location is the sub-folder in the TEMP folder.

TEurekaLogFileType.ftSavedBugReport

TEurekaLogFileType.ftScreenshot

Screenshot file name (.png). Default location is the sub-folder in the TEMP folder.

TEurekaLogFileType.ftXML

Name of XML bug report (.elx). Default location is the sub-folder in the TEMP folder.

TEurekaLogFileType.ftZIP

Packed bug report for sending (ZIP/ELP, including additional files, screenshot, etc.) (.elp). Default location is the sub-folder in the TEMP folder.

TEurekaLogFileType.ftZIPCopy

File name for "Save copy in case of send failure" option (.elp). Default location is the My Documents folder.

TEurekaModuleType

Alias for TModuleType (appendix B).

TEurekaModuleType = TModuleType;

Remarks.

See description of TModuleType (appendix B).

TIssueIDType

Type of the issue ID in the bug tracker.

TIssueIDType = (
iitUnspecified,
iitInteger,
iitUnsigned,
iitHex8,
iitHex16,
iitString,
iitHRESULT,
iitWin32,
iitHTTP
);

Remarks.

This type indicates how issue ID should be formatted.

TMemoryError

Type of detected memory error.

TMemoryError = (
leNone,
leOverflow,
leMultiFree,
leObjectInUse,
leInvalidBlock,
leCorruption,
leHang,
leUseAfterFree,
leOutOfMemory,
leUninstalled
);

Members.

leCorruption (appendix B, TMemoryError.leCorruption)

While the passed block is valid, but the internal linked list is corrupted.

leHang (appendix B, TMemoryError.leHang)

Memory manager is unresponsive, e.g. hang, deadlocked, etc. This error can happen due to damaged internal structures of memory manager, terminated thread, etc.

leInvalidBlock (appendix B, TMemoryError.leInvalidBlock)

A pointer to invalid block was passed to FreeMem or ReallocMem. Invalid block is a block which does not contain a valid EurekaLog header. This can be a valid, but corrupted block (overflow/underflow), it can be already released block (double-free), it can be a fully rogue/random pointer, it can be a block allocated by another memory manager.

leMultiFree (appendix B, TMemoryError.leMultiFree)

Double-free of memory block or object.

leNone (appendix B, TMemoryError.leNone)

No memory error is detected.

leObjectInUse (appendix B, TMemoryError.leObjectInUse)

Attempt to delete object, which is still in use

leOutOfMemory (appendix B, TMemoryError.leOutOfMemory)

There is not enough memory to allocate requested amount of memory in GetMem or AllocMem.

leOverflow (appendix B, TMemoryError.leOverflow)

Buffer overflow is detected. Some code damaged/overwrote internal EurekaLog's headers.

leUninstalled (appendix B, TMemoryError.leUninstalled)

Application made attempt to call memory manager's function after finalization. This usually happens when using shared memory manager and wrong finalization order for DLLs.

leUseAfterFree (appendix B, TMemoryError.leUseAfterFree)

Detected attempt to use already released object or interface. A virtual method was called on already deleted object.

Remarks.

This type is used in TMemLeaksError event handler.

TMemoryError.leCorruption

While the passed block is valid, but the internal linked list is corrupted.

TMemoryError.leHang

Memory manager is unresponsive, e.g. hang, deadlocked, etc. This error can happen due to damaged internal structures of memory manager, terminated thread, etc.

TMemoryError.leInvalidBlock

TMemoryError.leMultiFree

Double-free of memory block or object.

TMemoryError.leNone

No memory error is detected.

TMemoryError.leObjectInUse

Attempt to delete object, which is still in use

TMemoryError.leOutOfMemory

There is not enough memory to allocate requested amount of memory in GetMem or AllocMem.

TMemoryError.leOverflow

Buffer overflow is detected. Some code damaged/overwrote internal EurekaLog's headers.

TMemoryError.leUninstalled

Application made attempt to call memory manager's function after finalization. This usually happens when using shared memory manager and wrong finalization order for DLLs.

TMemoryError.leUseAfterFree

Detected attempt to use already released object or interface. A virtual method was called on already deleted object.

TMemoryErrors

Defines set of possible memory errors.

TMemoryErrors = set of TMemoryError;

Remarks.

This type is used in MemLeaksErrorsToIgnore global variable.

TModuleType

Indicates kind of executable module.

TModuleType = (
mtUnknown,
mtProgram,
mtLibrary,
mtPackage
);

Members.

mtLibrary (appendix B, TModuleType.mtLibrary)

.dll file

mtPackage (appendix B, TModuleType.mtPackage)

.bpl file

mtProgram (appendix B, TModuleType.mtProgram)

.exe file

mtUnknown (appendix B, TModuleType.mtUnknown)

Module type wasn't recognized

Remarks.

Module type is used to draw call stack items and for design/compiler part of EurekaLog.

TModuleType.mtLibrary

.dll file

TModuleType.mtPackage

.bpl file

TModuleType.mtProgram

.exe file

TModuleType.mtUnknown

Module type wasn't recognized

TPointerRecord

Header for memory blocks allocated by EurekaLog.

TPointerRecord = packed record
  Prev, Next: PPointerRecord;
  Module: HMODULE;
  Tag: Pointer;
  OrigSize: PtrUInt;
  SingleSize: PtrUInt;
  TotalSize: PtrUInt;
  Name: TCustomName;
  Parent: Pointer;
  BlockState: TBlockState;
  BlockType: TBlockType;
  Reserved1: WORD;
  ThreadID: DWORD;
  Count: DWORD;
  Flags: DWORD;
  CallStack: TCallStackArray;
  GuardBlock: DWord;
end;

Remarks.

This data structure represents internal EurekaLog header for allocated memory blocks. Memory block's data starts immediately after this structure.

Warning. This data type is subject to change. Consider it to be undocumented.

TPointerRecord.BlockState

State of memory block.

  BlockState: TBlockState;

Value.

Indicates state of the block.

Remarks.

This value represents state (allocated, released, filtered, etc.) of the memory block.

TPointerRecord.BlockType

Type of memory block.

  BlockType: TBlockType;

Value.

Indicate type of the block.

Remarks.

This value represents type of memory block (object, array, string or RAW).

TPointerRecord.CallStack

Call stack of allocation.

  CallStack: TCallStackArray;

Value.

Array of RAW pointers representing return addresses.

Remarks.

This is call stack taken when memory block was first allocated.

Tip. Call stack holds array of return addresses. Return address is not the same as pointer to call instruction.

TPointerRecord.SingleSize

Memory block size.

  SingleSize: PtrUInt;

Value.

Actual size of the block, in bytes.

Remarks.

This value represents size of the memory block in bytes.

TResponse

Result of exception's processing or sending bug report.

TResponse = packed record
  SendResult: TSendResult;
  IssueID: Int64;
  IssueIDStr: String;
  IssueIDType: TIssueIDType;
  ErrorCode: Integer;
  ErrorMessage: String;
  SuccessMessage: String;
end;

Remarks.

This record is used to hold result of processing or sending. There are fields for status, codes, messages and ticket (issue) ID.

This data type is returned by all EurekaLog methods and functions which process exceptions.

TResponse.ErrorCode

Error code for failed operations.

  ErrorCode: Integer;

Value.

System or any other error code. Numeric value. May be 0, if no error code available.

Remarks.

Optional error code associated with failed operations. The exact meaning of error code is not defined. It can be system error code, WinINet error code, etc.

The only thing that you can do with this field - display it to user.

Caution!

This value can be 0 for failed operations. Do not assume success/failure status of operation based on this field. Use SendResult field to determinate generic state of operation.

TResponse.ErrorMessage

Error message (failed operations only).

  ErrorMessage: String;

Value.

Error message in arbitrary format.

Remarks.

Optional error message which describes occurred error in human-readable form.

This value is supposed to be shown to end-user.

TResponse.IssueID

Ticket/issue ID in bug tracker (number).

  IssueID: Int64;

Value.

ID of processed exception in bug tracker.

Remarks.

This field is set only if exception report was sent to bug tracker which supports feedback (allow to retrieve ID).

ID is stored in format of bug tracker. The IssueIDType field indicate type of the ID.

This value can be set only for succeeded operations.

TResponse.IssueIDStr

Ticket/issue ID in bug tracker (string).

  IssueIDStr: String;

Value.

ID of processed exception in bug tracker.

Remarks.

This field is set only if exception report was sent to bug tracker which supports feedback (allow to retrieve ID).

ID is stored in format of bug tracker. The IssueIDType field indicate type of the ID.

This value can be set only for succeeded operations.

TResponse.IssueIDType

Type of the IssueID field.

  IssueIDType: TIssueIDType;

Value.

ID's type of processed exception in bug tracker.

Remarks.

This field is set only if exception report was sent to bug tracker which supports feedback (allow to retrieve ID).

This value can be set only for succeeded operations.

TResponse.SendResult

Status of operation.

  SendResult: TSendResult;

Value.

HRESULT value indicating success/failure status of operation. See TSendResult (appendix B) for more information.

Remarks.

This value indicate result of exception's processing. There are 3 success codes (Send/BugClosed/NoExceptionInfo) and multiple error (failure) codes.

Success codes indicate that exception was processed successfully. "No exception to process/handle" is also considered as success.

Failure codes indicate that there was some kind of a error during exception processing. Restart and cancelling are considered as failures (however, often there are special cases to handle these codes).

TResponse.SuccessMessage

Success message (succeeded operations only).

  SuccessMessage: String;

Value.

Success message in arbitrary format. This message may also be a URL.

Remarks.

This field may contain optional "success" message, which is supposed to be shown to end-user. Typically, this value is set by send method which works with bug trackers. Bug trackers may report status of bug (open/closed), instructions to do ("please, download update - it fixes this issue"), and URL to open.

This field may contain either human-readable message or URL.

Human-readable message must be shown to end-user in a message box (or via similar feature in your application).

URLs must be opened in default application.

You can determinate kind of string by checking beginning of the string: does it start with URL protocol name? Currently EurekaLog is able to recognize HTTP/HTTPS protocols and automatically launch web-browser when "Show success message" option is used.

TSendResult

Result kind for exception processing.

TSendResult = (
srSent = S_OK,
srBugClosed = S_FALSE,
srBugReopen = $00000003,
srNoExceptionInfo = S_NONE,
srRestart = E_RESTART,
srCancelled = E_CANCELLED,
srUnknownError = E_UNEXPECTED,
srUnsupportedSender = E_NOINTERFACE,
srConnectionError = E_CONNECTION_REFUSED,
srObsoleteVersion = E_OBSOLETE,
srInvalidLogin = E_LOGON_FAILED,
srInvalidSearch = E_INVALID_SEARCH,
srInvalidSelection = E_INVALID_SELECTION,
srInvalidRead = E_INVALID_READ,
srInvalidInsert = E_INVALID_INSERT,
srInvalidModify = E_INVALID_MODIFY
);

Members.

srBugClosed (appendix B, TSendResult.srBugClosed)

[SUCCESS] Exception was processed without errors. Sending method is set up, bug report was sent succcessfully and (most importantly) send method discovered that this exception is marked as "Fixed" in the target bug tracker.

srBugReopen (appendix B, TSendResult.srBugReopen)

srCancelled (appendix B, TSendResult.srCancelled)

[FAILURE] Exception processing was cancelled by user via dialog.

srConnectionError (appendix B, TSendResult.srConnectionError)

[FAILURE] Network connection error. This includes DNS errors.

srInvalidInsert (appendix B, TSendResult.srInvalidInsert)

[FAILURE] There was error when creating (opening) new case (ticket). For non-bug trackers methods this means error during content sending.

srInvalidLogin (appendix B, TSendResult.srInvalidLogin)

[FAILURE] There was error during log in stage. Most common reason is wrong login/password pair.

srInvalidModify (appendix B, TSendResult.srInvalidModify)

[FAILURE] There was error when modifying existing case (ticket). Applicable only for bug trackers.

srInvalidRead (appendix B, TSendResult.srInvalidRead)

[FAILURE] There was error during reading project or case options. Possible access denied error?

srInvalidSearch (appendix B, TSendResult.srInvalidSearch)

[FAILURE] There was error during project search. Reasons may be access denied or project was removed. Typically this is applicable only for bug trackers.

srInvalidSelection (appendix B, TSendResult.srInvalidSelection)

[FAILURE] There was error during selecting project (making project active). This value is used rarely, most often it's set by web-browser access methods.

srNoExceptionInfo (appendix B, TSendResult.srNoExceptionInfo)

[SUCCESS] There is no active exception. Nothing to do.

srObsoleteVersion (appendix B, TSendResult.srObsoleteVersion)

[FAILURE] Project version is obsolete. Bug reports are no longer required, submission is closed.

srRestart (appendix B, TSendResult.srRestart)

[FAILURE] Exception processing must be restarted. This value is typically used to switch between dialogs and handlers.

srSent (appendix B, TSendResult.srSent)

[SUCCESS] Exception was processed without errors. If sending is set up - then bug report was sent succcessfully.

srUnknownError (appendix B, TSendResult.srUnknownError)

[FAILURE] Common error code. It's used when no other code can be used.

srUnsupportedSender (appendix B, TSendResult.srUnsupportedSender)

[FAILURE] Unknown sender class. It's either wrong class name specified or sender class wasn't registered.

Remarks.

This value indicate result of exception's processing. There are 3 success codes (Send/BugClosed/NoExceptionInfo) and multiple error (failure) codes.

Success codes indicate that exception was processed successfully. "No exception to process/handle" is also considered as success.

UnknownError code is most general failure code. It's used when other codes can not be used.

TSendResult.srBugClosed

TSendResult.srBugReopen

TSendResult.srCancelled

[FAILURE] Exception processing was cancelled by user via dialog.

TSendResult.srConnectionError

[FAILURE] Network connection error. This includes DNS errors.

TSendResult.srInvalidInsert

[FAILURE] There was error when creating (opening) new case (ticket). For non-bug trackers methods this means error during content sending.

TSendResult.srInvalidLogin

[FAILURE] There was error during log in stage. Most common reason is wrong login/password pair.

TSendResult.srInvalidModify

[FAILURE] There was error when modifying existing case (ticket). Applicable only for bug trackers.

TSendResult.srInvalidRead

[FAILURE] There was error during reading project or case options. Possible access denied error?

TSendResult.srInvalidSearch

[FAILURE] There was error during project search. Reasons may be access denied or project was removed. Typically this is applicable only for bug trackers.

TSendResult.srInvalidSelection

[FAILURE] There was error during selecting project (making project active). This value is used rarely, most often it's set by web-browser access methods.

TSendResult.srNoExceptionInfo

[SUCCESS] There is no active exception. Nothing to do.

TSendResult.srObsoleteVersion

[FAILURE] Project version is obsolete. Bug reports are no longer required, submission is closed.

TSendResult.srRestart

[FAILURE] Exception processing must be restarted. This value is typically used to switch between dialogs and handlers.

TSendResult.srSent

[SUCCESS] Exception was processed without errors. If sending is set up - then bug report was sent succcessfully.

TSendResult.srUnknownError

[FAILURE] Common error code. It's used when no other code can be used.

TSendResult.srUnsupportedSender

[FAILURE] Unknown sender class. It's either wrong class name specified or sender class wasn't registered.

TSendScreenshot

Specifies screen area.

TSendScreenshot = (
ssNone,
ssForegroundWindow,
ssActiveWindow,
ssApplication,
ssWorkarea,
ssPrimary,
ssDesktop
);

Members.

ssActiveWindow (appendix B, TSendScreenshot.ssActiveWindow)

Screen area occupied by window returned by GetActiveWindow.

ssApplication (appendix B, TSendScreenshot.ssApplication)

Screen area occupied by all windows belonging to current application. E.g. bounding rectangle of all application's windows.

ssDesktop (appendix B, TSendScreenshot.ssDesktop)

Full virtual screen. The virtual screen is the bounding rectangle of all display monitors.

ssForegroundWindow (appendix B, TSendScreenshot.ssForegroundWindow)

Screen area occupied by window returned by GetForegroundWindow.

ssNone (appendix B, TSendScreenshot.ssNone)

Do not take screenshot.

ssPrimary (appendix B, TSendScreenshot.ssPrimary)

Screen area of primary display monitor.

ssWorkarea (appendix B, TSendScreenshot.ssWorkarea)

Work area on the primary display monitor. The work area is the portion of the screen not obscured by the system taskbar or by application desktop toolbars.

Remarks.

This type indicate what screen area should be included for the screenshot.

ssNone disables screenshot.

ssDesktop captures full screenshot.

Other values captures only some part.

TSendScreenshot.ssActiveWindow

Screen area occupied by window returned by GetActiveWindow.

TSendScreenshot.ssApplication

Screen area occupied by all windows belonging to current application. E.g. bounding rectangle of all application's windows.

TSendScreenshot.ssDesktop

Full virtual screen. The virtual screen is the bounding rectangle of all display monitors.

TSendScreenshot.ssForegroundWindow

Screen area occupied by window returned by GetForegroundWindow.

TSendScreenshot.ssNone

Do not take screenshot.

TSendScreenshot.ssPrimary

Screen area of primary display monitor.

TSendScreenshot.ssWorkarea

Work area on the primary display monitor. The work area is the portion of the screen not obscured by the system taskbar or by application desktop toolbars.

TSysErrorCode

A type for GetLastError/SetLastError.

TSysErrorCode = Cardinal;

Remarks.

EurekaLog introduces this type, because SysErrorMessage work with Integer in Delphi 4-2007, but works with Cardinal in Delphi 2009+. GetLastError/SetLastError work with Cardinal in all Delphi versions.

TSysErrorCode defines data type to be used with GetLastError/SetLastError/SysErrorMessage. Fixed SysErrorMessage routine is available in ECompatibility (appendix C) unit.

EZip

TStreamConstructor

Function to Create a Compression/Decompression stream

TStreamConstructor = function(
  InStream: Classes.TStream;
  const ZipFile: TZipFile;
  const Item: TZipHeader;
  const AOwnStream: Boolean
): Classes.TStream;

TZipCompression

Zip compression method.

TZipCompression = (
zcStored,
zcShrunk,
zcReduce1,
zcReduce2,
zcReduce3,
zcReduce4,
zcImplode,
zcTokenize,
zcDeflate,
zcDeflate64,
zcPKImplode,
zcReserved11,
zcBZIP2,
zcReserved13,
zcLZMA,
zcReserved15,
zcReserved16,
zcReserved17,
zcTERSE,
zcLZ77,
zcWavePack = 97,
zcPPMdI1
);

Members.

zcBZIP2 (appendix B, TZipCompression.zcBZIP2)

File is compressed using BZIP2 algorithm

zcDeflate (appendix B, TZipCompression.zcDeflate)

The file is Deflated

zcDeflate64 (appendix B, TZipCompression.zcDeflate64)

Enhanced Deflating using Deflate64

zcImplode (appendix B, TZipCompression.zcImplode)

The file is Imploded

zcLZ77 (appendix B, TZipCompression.zcLZ77)

IBM LZ77 z Architecture (PFS)

zcLZMA (appendix B, TZipCompression.zcLZMA)

LZMA (EFS)

zcPKImplode (appendix B, TZipCompression.zcPKImplode)

PKWARE Data Compression Library Imploding (old IBM TERSE)

zcPPMdI1 (appendix B, TZipCompression.zcPPMdI1)

PPMd version I, Rev 1

zcReduce1 (appendix B, TZipCompression.zcReduce1)

The file is Reduced with compression factor 1

zcReduce2 (appendix B, TZipCompression.zcReduce2)

The file is Reduced with compression factor 2

zcReduce3 (appendix B, TZipCompression.zcReduce3)

The file is Reduced with compression factor 3

zcReduce4 (appendix B, TZipCompression.zcReduce4)

The file is Reduced with compression factor 4

zcReserved11 (appendix B, TZipCompression.zcReserved11)

Reserved by PKWARE

zcReserved13 (appendix B, TZipCompression.zcReserved13)

Reserved by PKWARE

zcReserved15 (appendix B, TZipCompression.zcReserved15)

Reserved by PKWARE

zcReserved16 (appendix B, TZipCompression.zcReserved16)

Reserved by PKWARE

zcReserved17 (appendix B, TZipCompression.zcReserved17)

Reserved by PKWARE

zcShrunk (appendix B, TZipCompression.zcShrunk)

The file is Shrunk

zcStored (appendix B, TZipCompression.zcStored)

The file is stored (no compression)

zcTERSE (appendix B, TZipCompression.zcTERSE)

File is compressed using IBM TERSE (new)

zcTokenize (appendix B, TZipCompression.zcTokenize)

Reserved for Tokenizing compression algorithm

zcWavePack (appendix B, TZipCompression.zcWavePack)

WavPack compressed data

TZipCompression.zcBZIP2

File is compressed using BZIP2 algorithm

TZipCompression.zcDeflate

The file is Deflated

TZipCompression.zcDeflate64

Enhanced Deflating using Deflate64

TZipCompression.zcImplode

The file is Imploded

TZipCompression.zcLZ77

IBM LZ77 z Architecture (PFS)

TZipCompression.zcLZMA

LZMA (EFS)

TZipCompression.zcPKImplode

PKWARE Data Compression Library Imploding (old IBM TERSE)

TZipCompression.zcPPMdI1

PPMd version I, Rev 1

Requirements.

IDE

Delphi 6 or above; C++ Builder 6 or above

TZipCompression.zcReduce1

The file is Reduced with compression factor 1

TZipCompression.zcReduce2

The file is Reduced with compression factor 2

TZipCompression.zcReduce3

The file is Reduced with compression factor 3

TZipCompression.zcReduce4

The file is Reduced with compression factor 4

TZipCompression.zcReserved11

Reserved by PKWARE

TZipCompression.zcReserved13

Reserved by PKWARE

TZipCompression.zcReserved15

Reserved by PKWARE

TZipCompression.zcReserved16

Reserved by PKWARE

TZipCompression.zcReserved17

Reserved by PKWARE

TZipCompression.zcShrunk

The file is Shrunk

TZipCompression.zcStored

The file is stored (no compression)

TZipCompression.zcTERSE

File is compressed using IBM TERSE (new)

TZipCompression.zcTokenize

Reserved for Tokenizing compression algorithm

TZipCompression.zcWavePack

WavPack compressed data

Requirements.

IDE

Delphi 6 or above; C++ Builder 6 or above

TZipEndOfCentralHeader

Final block written to zip file

TZipEndOfCentralHeader = packed record
  DiskNumber: UInt16;
  CentralDirStartDisk: UInt16;
  NumEntriesThisDisk: UInt16;
  CentralDirEntries: UInt16;
  CentralDirSize: UInt32;
  CentralDirOffset: UInt32;
  CommentLength: UInt16;
end;

Remarks.

"Comments" field follows this record.

TZipHeader

TZipHeader contains information about a file in a zip archive.

TZipHeader = packed record
  MadeByVersion: UInt8;
  HostOS: UInt8;
  RequiredVersion: UInt16;
  Flag: UInt16;
  CompressionMethod: UInt16;
  ModifiedDateTime: UInt32;
  CRC32: UInt32;
  CompressedSize: UInt32;
  UncompressedSize: UInt32;
  FileNameLength: UInt16;
  ExtraFieldLength: UInt16;
  FileCommentLength: UInt16;
  DiskNumberStart: UInt16;
  InternalAttributes: UInt16;
  ExternalAttributes: UInt32;
  LocalHeaderOffset: UInt32;
  FileName: String;
  FileNameRAW: RawByteString;
  ExtraField: TBytes;
  FileComment: String;
  FileCommentRAW: RawByteString;
  TimeCreate: TDateTime;
  TimeChange: TDateTime;
  TimeAccess: TDateTime;
end;

Remarks.

This record is overloaded for use in reading/writing ZIP [Local file header] and the Central Directory's [file header].

See PKZIP Application Note section V. General Format of a .ZIP file sub section J. Explanation of fields for more detailed description of each field's usage.

TZipHeader.HostOS

Version made by (HostOS byte; upper)

  HostOS: UInt8;

Remarks.

Indicates the compatibility of the file attribute information. If the external file attributes are compatible with MS-DOS and can be read by PKZIP for DOS version 2.04g then this value will be zero. If these attributes are not compatible, then this value will identify the host system on which the attributes are compatible. Software can use this information to determine the line record format for text files etc. The current mappings are:

0 - MS-DOS and OS/2 (FAT / VFAT / FAT32 file systems)
1 - Amiga
2 - OpenVMS
3 - UNIX
4 - VM/CMS
5 - Atari ST
6 - OS/2 H.P.F.S.
7 - Macintosh
8 - Z-System
9 - CP/M
10 - Windows NTFS
11 - MVS (OS/390 - Z/OS)
12 - VSE
13 - Acorn Risc
14 - VFAT
15 - alternate MVS
16 - BeOS
17 - Tandem
18 - OS/400
19 - OS/X (Darwin)
20 thru 255 - unused

TZipHeader.MadeByVersion

Version made by (software byte; lower)

  MadeByVersion: UInt8;

Remarks.

Indicates the ZIP specification version (the version of this document) supported by the software used to encode the file. The value/10 indicates the major version number, and the value mod 10 is the minor version number.

Tip. Start of Central Header

TZipHeader.RequiredVersion

Version needed to extract (2 bytes)

  RequiredVersion: UInt16;

Remarks.

The minimum supported ZIP specification version needed to extract the file. This value is based on the specific format features a ZIP program must support to be able to extract the file. If multiple features are applied to a file, the minimum version should be set to the feature having the highest value. New features or feature changes affecting the published format specification will be implemented using higher version numbers than the last published value to avoid conflict.Current minimum feature versions are as defined below:

1.0 - Default value
1.1 - File is a volume label
2.0 - File is a folder (directory)
2.0 - File is compressed using Deflate compression
2.0 - File is encrypted using traditional PKWARE encryption
2.1 - File is compressed using Deflate64(tm)
2.5 - File is compressed using PKWARE DCL Implode
2.7 - File is a patch data set
4.5 - File uses ZIP64 format extensions
4.6 - File is compressed using BZIP2 compression (1)
5.0 - File is encrypted using DES
5.0 - File is encrypted using 3DES
5.0 - File is encrypted using original RC2 encryption
5.0 - File is encrypted using RC4 encryption
5.1 - File is encrypted using AES encryption
5.1 - File is encrypted using corrected RC2 encryption (2)
5.2 - File is encrypted using corrected RC2-64 encryption (2)
6.1 - File is encrypted using non-OAEP key wrapping (3)
6.2 - Central directory encryption
6.3 - File is compressed using LZMA
6.3 - File is compressed using PPMd (4)
6.3 - File is encrypted using Blowfish
6.3 - File is encrypted using Twofish

Note. (1) Early 7.x (pre-7.2) versions of PKZIP incorrectly set the version needed to extract for BZIP2 compression to be 50 when it should have been 46.

Note. (2) RC2 corrections from the ZIP Strong Encryption Specification are not specified in this version table; it is not a complete implementation contract for that format.

Note. (3) Certificate encryption using non-OAEP key wrapping is the intended mode of operation for all versions beginning with 6.1. Support for OAEP key wrapping should only be used for backward compatibility when sending ZIP files to be opened by versions of PKZIP older than 6.1 (5.0 or 6.0).

Note. (4) Files compressed using PPMd should set the version needed to extract field to 6.3, however, not all ZIP programs enforce this and may be unable to decompress data files compressed using PPMd if this value is set. When using ZIP64 extensions, the corresponding value in the zip64 end of central directory record should also be set. This field should be set appropriately to indicate whether Version 1 or Version 2 format is in use.

Tip. Start of Local Header