---
product: Chilkat
product_version: 11.7.0
language: c
language_label: C
class: Log
license: free
deprecated: false
reference_html: https://www.chilkatsoft.com/refdoc/c_CkLogRef.html
---
# Chilkat Log — C — v11.7.0

> Chilkat 11.7.0 · language=c · class=Log
> Other versions: replace `11.7.0` in this URL. Other languages: `https://www.chilkatsoft.com/ai-docs/v/11.7.0/<lang>/classes/Log.md`.
> Language-wide rules (install, unlock, error model, strings/bytes): `https://www.chilkatsoft.com/ai-docs/v/11.7.0/c/guide.md`.

## Purpose

**Build readable structured diagnostic logs with nested context and tagged values.**

`Chilkat.Log` is a lightweight structured logging helper for creating readable diagnostic logs from application code. It can record nested operation contexts, informational messages, error messages, timestamps, integers, 64-bit integers, tagged values, binary data, Base64 data, hex data, shortened data previews, and computed hashes. It is useful when code needs a clear step-by-step record of operations, inputs, outputs, and diagnostic values for troubleshooting.

**Nested operation context**

Use `EnterContext` and `LeaveContext` to group log entries under readable operation names.

**Messages and errors**

Add informational messages, error messages, and tagged text values to explain what the application is doing.

**Numbers and timestamps**

Log integers, 64-bit integers, timestamps, and date/time values when tracing state changes or timing-sensitive workflows.

**Binary diagnostics**

Record binary data as Base64, hex, or shortened previews so byte-level values can be inspected safely in text logs.

**Hash logging**

Compute and log hashes of data when comparing content, verifying transformations, or avoiding full data dumps.

**Clear and reuse**

Clear the log and continue building new diagnostic output during repeated operations or test runs.

**Common pattern:** Create a `Log` object, enter a named context for the operation, log the important values and decisions as the code runs, leave the context, and inspect the resulting text if troubleshooting is needed. Use `Chilkat.Log` for application-level diagnostic output; use `LastErrorText` on Chilkat objects for detailed diagnostics from Chilkat method calls.

For an extended overview, see [Log Class Overview](https://www.chilkatsoft.com/log_class_overview.asp).

## Object creation, unlocking and error handling

**Create/Dispose**

```c
HCkLog instance = CkLog_Create();
// ...
CkLog_Dispose(instance);
```

`HCkLog CkLog_Create(void);`

Creates an instance of the HCkLog object and returns a handle ("void \*" pointer). The handle is passed in the 1st argument for the functions listed on this page.

`void CkLog_Dispose(HCkLog handle);`

Objects created by calling CkLog_Create must be freed by calling this method. A memory leak occurs if a handle is not disposed by calling this function. Also, any handle returned by a Chilkat "C" function must also be freed by the application by calling the appropriate Dispose method, such as CkLog_Dispose.

Call `Global.UnlockBundle` once at the start of the program, before using this or any other Chilkat class. Any string unlocks a fully functional 30-day trial; a purchased unlock code is used in production. See `guide.md` for the exact code in C.

## Members common to every Chilkat class

Documented once per language in `common-members.md`; listed here so this page is self-contained.

| Property | Signature | Access | Meaning |
|---|---|---|---|
| `DebugLogFilePath` | `void CkLog_getDebugLogFilePath(HCkLog cHandle, HCkString retval); void CkLog_putDebugLogFilePath(HCkLog cHandle, const char *newVal); const char *CkLog_debugLogFilePath(HCkLog cHandle);` | read/write | If set to a file path, this property logs the LastErrorText of each Chilkat method or property call to the specified file. |
| `LastErrorHtml` | `void CkLog_getLastErrorHtml(HCkLog cHandle, HCkString retval); const char *CkLog_lastErrorHtml(HCkLog cHandle);` | read-only | Provides HTML-formatted information about the last called method or property. |
| `LastErrorText` | `void CkLog_getLastErrorText(HCkLog cHandle, HCkString retval); const char *CkLog_lastErrorText(HCkLog cHandle);` | read-only | Provides plain text information about the last called method or property. |
| `LastErrorXml` | `void CkLog_getLastErrorXml(HCkLog cHandle, HCkString retval); const char *CkLog_lastErrorXml(HCkLog cHandle);` | read-only | Provides XML-formatted information about the last called method or property. |
| `LastMethodSuccess` | `BOOL CkLog_getLastMethodSuccess(HCkLog cHandle); void CkLog_putLastMethodSuccess(HCkLog cHandle, BOOL newVal);` | read/write | Indicates the success or failure of the most recent method call: `TRUE` means success, `FALSE` means failure. |
| `Utf8` | `BOOL CkLog_getUtf8(HCkLog cHandle); void CkLog_putUtf8(HCkLog cHandle, BOOL newVal);` | read/write | When set to `TRUE`, all `const char *` arguments and return values are interpreted as UTF-8 strings. |
| `VerboseLogging` | `BOOL CkLog_getVerboseLogging(HCkLog cHandle); void CkLog_putVerboseLogging(HCkLog cHandle, BOOL newVal);` | read/write | If set to `TRUE`, then the contents of LastErrorText (or LastErrorXml, or LastErrorHtml) may contain more verbose information. |
| `Version` | `void CkLog_getVersion(HCkLog cHandle, HCkString retval); const char *CkLog_version(HCkLog cHandle);` | read-only | Version of the component/library, such as "10.1.0" |

## Member index

| Member | Kind | Signature |
|---|---|---|
| `Clear` | method | `void CkLog_Clear(HCkLog cHandle, const char *initialTag);` |
| `EnterContext` | method | `void CkLog_EnterContext(HCkLog cHandle, const char *tag);` |
| `LeaveContext` | method | `void CkLog_LeaveContext(HCkLog cHandle);` |
| `LogData` | method | `void CkLog_LogData(HCkLog cHandle, const char *tag, const char *message);` |
| `LogDataBase64_2` | method | `void CkLog_LogDataBase64_2(HCkLog cHandle, const char *tag, const unsigned char *pByteData, unsigned long szByteData);` |
| `LogDataHex2` | method | `void CkLog_LogDataHex2(HCkLog cHandle, const char *tag, const unsigned char *pByteData, unsigned long szByteData);` |
| `LogDataMax` | method | `void CkLog_LogDataMax(HCkLog cHandle, const char *tag, const char *message, int maxNumChars);` |
| `LogDateTime` | method | `void CkLog_LogDateTime(HCkLog cHandle, const char *tag, BOOL gmt);` |
| `LogError` | method | `void CkLog_LogError(HCkLog cHandle, const char *message);` |
| `LogHash2` | method | `void CkLog_LogHash2(HCkLog cHandle, const char *tag, const char *hashAlg, const unsigned char *pByteData, unsigned long szByteData);` |
| `LogInfo` | method | `void CkLog_LogInfo(HCkLog cHandle, const char *message);` |
| `LogInt` | method | `void CkLog_LogInt(HCkLog cHandle, const char *tag, int value);` |
| `LogInt64` | method | `void CkLog_LogInt64(HCkLog cHandle, const char *tag, __int64 value);` |
| `LogTimestamp` | method | `void CkLog_LogTimestamp(HCkLog cHandle, const char *tag);` |

Deprecated members are listed at the end of this file with their replacements; do not use them in new code.

## Methods

### Log.Clear

`Chilkat 11.7.0 · c · Log · Clear · method · since 9.5.0.44`

```c
void CkLog_Clear(HCkLog cHandle, const char *initialTag);
```

Clears all existing log entries and starts a new log whose top-level context is named `initialTag`.

**Typical use:** Call this at the beginning of an operation or test run, then add entries with the other `Log*` methods. The completed structured log can be inspected through the Log object's diagnostic text, such as `LastErrorText`.

### Log.EnterContext

`Chilkat 11.7.0 · c · Log · EnterContext · method · since 9.5.0.44`

```c
void CkLog_EnterContext(HCkLog cHandle, const char *tag);
```

Begins a nested logging context named `tag`. Entries written after this call are grouped inside the new context until a matching `LeaveContext` is called.

**Balanced contexts:** Pair each `EnterContext` with `LeaveContext`. Contexts may be nested to reflect operation hierarchy.

### Log.LeaveContext

`Chilkat 11.7.0 · c · Log · LeaveContext · method · since 9.5.0.44`

```c
void CkLog_LeaveContext(HCkLog cHandle);
```

Ends the current nested logging context and returns logging to its parent context.

**Empty contexts are omitted:** If nothing was logged after entering the current context, Chilkat automatically removes that empty context when it is left.

### Log.LogData

`Chilkat 11.7.0 · c · Log · LogData · method · since 9.5.0.44`

```c
void CkLog_LogData(HCkLog cHandle, const char *tag, const char *message);
```

Adds a tagged text value to the current context. The output associates `tag` with `message`, making this useful for named values such as filenames, paths, IDs, states, or protocol fields.

**Sensitive data:** Avoid logging passwords, private keys, access tokens, session secrets, or other sensitive values unless disclosure is intentional.

### Log.LogDataBase64_2

`Chilkat 11.7.0 · c · Log · LogDataBase64_2 · method · since 9.5.0.82`

```c
void CkLog_LogDataBase64_2(HCkLog cHandle, const char *tag, const unsigned char *pByteData, unsigned long szByteData);
```

Encodes `szByteData` bytes beginning at `pByteData` as Base64 and logs the result under `tag`.

**C++ byte buffer:** This form accepts a pointer and explicit byte count. Base64 is printable encoding only; it does not protect the logged data.

### Log.LogDataHex2

`Chilkat 11.7.0 · c · Log · LogDataHex2 · method · since 9.5.0.82`

```c
void CkLog_LogDataHex2(HCkLog cHandle, const char *tag, const unsigned char *pByteData, unsigned long szByteData);
```

Encodes `szByteData` bytes beginning at `pByteData` as hexadecimal text and logs the result under `tag`.

**C++ byte buffer:** This form accepts a pointer and explicit byte count. The caller must supply a valid buffer containing at least `szByteData` readable bytes.

### Log.LogDataMax

`Chilkat 11.7.0 · c · Log · LogDataMax · method · since 9.5.0.44`

```c
void CkLog_LogDataMax(HCkLog cHandle, const char *tag, const char *message, int maxNumChars);
```

Adds a tagged text value to the current context, but limits the logged value to at most the first `maxNumChars` characters of `message`.

**Diagnostic previews:** Use this when a value may be very large and only a leading preview is needed. The original input string is not modified.

### Log.LogDateTime

`Chilkat 11.7.0 · c · Log · LogDateTime · method · since 9.5.0.44`

```c
void CkLog_LogDateTime(HCkLog cHandle, const char *tag, BOOL gmt);
```

Logs the current date and time under `tag` using an RFC 822-style date/time representation. If `gmt` is `TRUE`, the logged time is GMT/UTC; otherwise local system time is used.

**Date/time vs. timestamp:** Use `LogDateTime` for a calendar date with timezone context. Use `LogTimestamp` for a time-of-day marker.

### Log.LogError

`Chilkat 11.7.0 · c · Log · LogError · method · since 9.5.0.44`

```c
void CkLog_LogError(HCkLog cHandle, const char *message);
```

Adds `message` as an error entry in the current logging context.

**Application diagnostics:** This is application-defined logging. It is separate from `LastErrorText` produced by other Chilkat objects when their operations fail.

### Log.LogHash2

`Chilkat 11.7.0 · c · Log · LogHash2 · method · since 9.5.0.82`

```c
void CkLog_LogHash2(HCkLog cHandle, const char *tag, const char *hashAlg, const unsigned char *pByteData, unsigned long szByteData);
```

Computes a hash of `szByteData` bytes beginning at `pByteData` and logs the digest as hexadecimal text under `tag`. Supported values for `hashAlg` are `SHA1`, `SHA256`, `SHA384`, `SHA512`, and `MD5`.

**Useful for comparison:** A digest is often preferable to dumping a large binary value when the goal is to determine whether two byte sequences are identical.

**Security note:** `MD5` and `SHA1` are not suitable when cryptographic collision resistance is required. Prefer SHA-256 or stronger for security-sensitive hashing.

### Log.LogInfo

`Chilkat 11.7.0 · c · Log · LogInfo · method · since 9.5.0.44`

```c
void CkLog_LogInfo(HCkLog cHandle, const char *message);
```

Adds `message` as an informational entry in the current logging context.

**Structured tracing:** Use informational entries for significant steps and decisions. Use `LogData` when the entry is better represented as a named value.

### Log.LogInt

`Chilkat 11.7.0 · c · Log · LogInt · method · since 9.5.0.44`

```c
void CkLog_LogInt(HCkLog cHandle, const char *tag, int value);
```

Adds the integer `value` to the current log under `tag`.

### Log.LogInt64

`Chilkat 11.7.0 · c · Log · LogInt64 · method · since 9.5.0.44`

```c
void CkLog_LogInt64(HCkLog cHandle, const char *tag, __int64 value);
```

Adds the signed 64-bit integer `value` to the current log under `tag`.

**64-bit values:** Useful for values such as large byte counts, file sizes, sequence numbers, or timestamps that can exceed ordinary integer ranges.

### Log.LogTimestamp

`Chilkat 11.7.0 · c · Log · LogTimestamp · method · since 9.5.0.44`

```c
void CkLog_LogTimestamp(HCkLog cHandle, const char *tag);
```

Logs the current time-of-day under `tag` in `HH:MM:SS:mmm` form, where `mmm` represents milliseconds.

**Timing note:** This is a time-of-day marker, not a monotonic elapsed-time measurement.

## Deprecated members — do not use in new code

| Member | Kind | Deprecated in | Use instead |
|---|---|---|---|
| `LogDataBase64` | method | before 11.6.1 | — |
| `LogDataHex` | method | before 11.6.1 | — |

