LogLib

Library "LogLib"
LogLib — unified logger with BUFFERED / PER_BAR / OFF modes,
bit-packed plot encoders, perf timing (tick/tock), load timer.
Step 2 patch: enum LogMode + LogLevel, method-first API, preserved facades.

f_logger_mode_off()

f_logger_mode_buffered()

f_logger_mode_stream()

f_logger_mode_per_bar()

f_q_unsigned(x, scale, maxv)
Quantize unsigned float to N-bit integer
Parameters:
x (float)
scale (float)
maxv (int)

f_q_signed(x, scale, bias, maxv)
Quantize signed float to N-bit integer with bias offset
Parameters:
x (float)
scale (float)
bias (int)
maxv (int)

f_pack3x10(a, b, c)
Pack three 10-bit values into single float for data window
Parameters:
a (int)
b (int)
c (int)

f_pack4x8(a, b, c, d)
Pack four 8-bit values into single float for data window
Parameters:
a (int)
b (int)
c (int)
d (int)

f_unpack3x10_a(packed)
Parameters:
packed (int)

f_unpack3x10_b(packed)
Parameters:
packed (int)

f_unpack3x10_c(packed)
Parameters:
packed (int)

f_unpack4x8_a(packed)
Parameters:
packed (int)

f_unpack4x8_b(packed)
Parameters:
packed (int)

f_unpack4x8_c(packed)
Parameters:
packed (int)

f_unpack4x8_d(packed)
Parameters:
packed (int)

f_encode_flags(s0, s1, s2, s3, s4, s5, s6, s7)
Encode 8 binary flags into 8-bit int
Parameters:
s0 (bool)
s1 (bool)
s2 (bool)
s3 (bool)
s4 (bool)
s5 (bool)
s6 (bool)
s7 (bool)

f_encode_ternary(s0, s1, s2, s3, s4)
Encode 5 ternary states (0,1,2) into base-3 integer
Parameters:
s0 (int)
s1 (int)
s2 (int)
s3 (int)
s4 (int)

f_decode_flag(encoded, bit_index)
Parameters:
encoded (int)
bit_index (int)

f_decode_ternary(encoded, state_index)
Parameters:
encoded (int)
state_index (int)

f_logger_new(mode, label, header, max_lines)
Initialize Logger (legacy signature, preserved)
Parameters:
mode (simple int): 0=OFF/STREAM-alias, 1=BUFFERED, 2=PER_BAR
label (simple string)
header (simple string)
max_lines (simple int)

f_logger_new_enum(mode, label, header, max_lines)
Enum-aware factory (preferred for new code)
Parameters:
mode (simple LogMode)
label (simple string)
header (simple string)
max_lines (simple int)

f_new_logger_buffered(label, header)
Quick BUFFERED logger with default thresholds (4000 chars / 2500 lines)
Parameters:
label (simple string)
header (simple string)

f_new_logger_per_bar(label, header)
Quick PER_BAR logger
Parameters:
label (simple string)
header (simple string)

f_new_logger_off()
Quick OFF logger (no-op, for production builds)

method append(l, row)
Append a row to the log; routes by mode.
Details OFF: discarded. BUFFERED: auto-flush when chars/lines threshold hit.
PER_BAR: caller must invoke flush() on barstate.isconfirmed.
Namespace types: Logger
Parameters:
l (Logger)
row (string)

method flush(l)
Explicit flush — drains any non-empty buffer.
Details Does NOT depend on barstate.islast. Caller invokes at natural
boundaries (RCOM completion, manual checkpoint, barstate.isconfirmed
for PER_BAR). BUFFERED mode primary flush remains automatic via append().
Namespace types: Logger
Parameters:
l (Logger)

method reset(l)
Reset buffer without flushing (drops accumulated content)
Namespace types: Logger
Parameters:
l (Logger)

method kv(l, key, val)
Append key=value diagnostic line
Namespace types: Logger
Parameters:
l (Logger)
key (string)
val (float)

method event(l, event_type, payload)
Append tagged event with bar_index prefix
Namespace types: Logger
Parameters:
l (Logger)
event_type (string)
payload (string)

method debug(l, msg)
Severity-tagged writers (level prefix added)
Namespace types: Logger
Parameters:
l (Logger)
msg (string)

method info(l, msg)
Namespace types: Logger
Parameters:
l (Logger)
msg (string)

method warn(l, msg)
Namespace types: Logger
Parameters:
l (Logger)
msg (string)

method error(l, msg)
ERROR — appends + immediate flush (drains accumulated buffer too)
Namespace types: Logger
Parameters:
l (Logger)
msg (string)

method tick(l, tag)
Namespace types: Logger
Parameters:
l (Logger)
tag (string)

method tock(l, tag)
Namespace types: Logger
Parameters:
l (Logger)
tag (string)

method get_last_timing(l)
Namespace types: Logger
Parameters:
l (Logger)

f_load_timer_new()

method update(lt)
Namespace types: LoadTimer
Parameters:
lt (LoadTimer)

method get_time(lt)
Namespace types: LoadTimer
Parameters:
lt (LoadTimer)

method get_formatted(lt)
Namespace types: LoadTimer
Parameters:
lt (LoadTimer)

method get_color(lt)
Namespace types: LoadTimer
Parameters:
lt (LoadTimer)

method log_time(lt, prefix)
Namespace types: LoadTimer
Parameters:
lt (LoadTimer)
prefix (string)

method log_to_logger(lt, logger)
Namespace types: LoadTimer
Parameters:
lt (LoadTimer)
logger (Logger)

method add_to_table(lt, t, col, row)
Namespace types: LoadTimer
Parameters:
lt (LoadTimer)
t (table)
col (int)
row (int)

Logger
Logger state. Mode field stays int for backward compat with persisted
Fields:
mode (series int): 0=OFF, 1=BUFFERED, 2=PER_BAR (matches LogMode ordinal)
buffer (series string)
line_count (series int)
max_lines (series int)
max_chars (series int)
header (series string)
header_written (series bool)
label (series string)
markers (map<string, int>)
last_delta_ms (series float)
last_tag (series string)

LoadTimer
Fields:
start_ms (series int)
load_secs_latched (series float)
captured (series bool)

Release Notes

v2

Added:
f_json_field_str(key, val)
Build JSON field: "key":value (string value)
Parameters:
key (string): Field name
val (string): String value (will be escaped)
Returns: JSON field string

f_json_field_num(key, val)
Build JSON field: "key":value (numeric value)
Parameters:
key (string): Field name
val (float): Numeric value (na becomes null)
Returns: JSON field string

f_json_field_int(key, val)
Build JSON field: "key":value (integer value)
Parameters:
key (string): Field name
val (int): Integer value
Returns: JSON field string

f_json_field_bool(key, val)
Build JSON field: "key":value (boolean value)
Parameters:
key (string): Field name
val (bool): Boolean value
Returns: JSON field string

f_debug_json(tag, fields)
Build complete JSON object for debug alerts
Parameters:
tag (string): Debug tag (DBG_* identifier)
fields (array<string>): Array of pre-built JSON fields from f_json_field_*
Returns: Complete JSON string with standard metadata

Release Notes

v3

Updated:
f_debug_json(source, tag, fields)
Build complete JSON object for debug alerts
Parameters:
source (string): Source identifier (indicator name/version for MCP filtering)
tag (string): Debug tag (DBG_* identifier)
fields (array<string>): Array of pre-built JSON fields from f_json_field_*
Returns: Complete JSON string with standard metadata

Release Notes

v4

Added:
f_inspector_new(enabled, startTime, endTime, rangeMode, title)
Parameters:
enabled (bool)
startTime (int)
endTime (int)
rangeMode (bool)
title (string)

method scan(self, atrLen)
Namespace types: Inspector
Parameters:
self (Inspector)
atrLen (simple int)

method add(self, onTarget, name, value)
Namespace types: Inspector
Parameters:
self (Inspector)
onTarget (bool)
name (string)
value (string)

method commit(self, onTarget, compact)
Namespace types: Inspector
Parameters:
self (Inspector)
onTarget (bool)
compact (bool)

method render(self, maxRows, lineColor, labelColor, txtColor)
Namespace types: Inspector
Parameters:
self (Inspector)
maxRows (int)
lineColor (color)
labelColor (color)
txtColor (color)

method log_to_console(self)
Namespace types: Inspector
Parameters:
self (Inspector)

LogRow
Per-bar log entry captured inside the range
Fields:
idx (series int): bar_index of the captured bar
hi (series float): high of the captured bar
lo (series float): low of the captured bar
body (series string): pre-built multiline body for this bar

Inspector
Inspector state container
Fields:
active (series bool): Master on/off
rangeMode (series bool): false = single bar, true = bar range
tgTime (series int): Start (or single) target time (ms)
tgTime2 (series int): End time for range mode (ms)
atr (series float): ATR for vertical spacing
title (series string): Label header
names (array<string>): Current-bar logged names (transient buffer)
vals (array<string>): Current-bar logged values (transient buffer)
rows (array<LogRow>): Captured rows (range mode → many; single → one)

Updated:
f_json_field_str(key, val)
Parameters:
key (string)
val (string)

f_json_field_num(key, val)
Parameters:
key (string)
val (float)

f_json_field_int(key, val)
Parameters:
key (string)
val (int)

f_json_field_bool(key, val)
Parameters:
key (string)
val (bool)

f_debug_json(source, tag, fields)
Parameters:
source (string)
tag (string)
fields (array<string>)

Release Notes

v5

Added:
f_label_cfg(nfeat, kind, tgtHigh, tgtLow, tgtReject, qLo, qHi, csvSafeMax, featPrec, autoResolve)
Parameters:
nfeat (simple int)
kind (simple CaptureKind)
tgtHigh (simple float)
tgtLow (simple float)
tgtReject (simple float)
qLo (simple float)
qHi (simple float)
csvSafeMax (simple int)
featPrec (simple int)
autoResolve (simple bool)

f_label_store_new(cfg)
Parameters:
cfg (LabelCfg)

method add_target(self, tms, cls)
Namespace types: LabelStore
Parameters:
self (LabelStore)
tms (int)
cls (series LabelClass)

method add_range(self, tStart, tEnd, cls)
Namespace types: LabelStore
Parameters:
self (LabelStore)
tStart (int)
tEnd (int)
cls (series LabelClass)

method feed_pivot(self, isHigh, pivotBar)
Namespace types: LabelStore
Parameters:
self (LabelStore)
isHigh (bool)
pivotBar (int)

method capture(self, feats, hi, lo, atr)
Namespace types: LabelStore
Parameters:
self (LabelStore)
feats (array<float>)
hi (float)
lo (float)
atr (float)

method finalize(self)
Namespace types: LabelStore
Parameters:
self (LabelStore)

method count(self, clsFilter)
Namespace types: LabelStore
Parameters:
self (LabelStore)
clsFilter (int)

method highs(self)
Namespace types: LabelStore
Parameters:
self (LabelStore)

method lows(self)
Namespace types: LabelStore
Parameters:
self (LabelStore)

method row_csv(self, s)
Namespace types: LabelStore
Parameters:
self (LabelStore)
s (LabSample)

method to_csv(self)
Namespace types: LabelStore
Parameters:
self (LabelStore)

method q8(self, f)
Namespace types: LabelStore
Parameters:
self (LabelStore)
f (float)

method to_q8(self)
Namespace types: LabelStore
Parameters:
self (LabelStore)

method export_auto(self, source, alertOn, logOn, logger)
Namespace types: LabelStore
Parameters:
self (LabelStore)
source (string)
alertOn (bool)
logOn (bool)
logger (Logger)

method export_one(self, source, slotId, alertOn, logOn, logger)
Namespace types: LabelStore
Parameters:
self (LabelStore)
source (string)
slotId (int)
alertOn (bool)
logOn (bool)
logger (Logger)

LabSample
One labeled sample. Features copied at capture (no lookback).
Fields:
slotId (series int): STABLE id == target registration order; downstream diff key
cls (series int): LabelClass ordinal resolved at finalize()
target (series float): Numeric target: HIGH=+1, LOW=-1, REJECT/NEUTRAL=0 (configurable)
idx (series int): bar_index at capture
tms (series int): time (ms) at capture
hi (series float)
lo (series float)
atr (series float): atr at capture (spacing/QC)
feats (array<float>): copied feature vector (length == cfg.nfeat)
rangeId (series int): range group id (RANGE mode), else -1

LabTarget
Pending target spec registered by the host before capture.
Fields:
slotId (series int): stable registration index (diff key)
tStart (series int): start (or single) time in ms
tEnd (series int): end time in ms (RANGE only; na for point targets)
cls (series int): user-chosen LabelClass (AUTO triggers pivot resolution)
matched (series bool): true once a bar matched (point targets, dedup)
rangeId (series int): stable id for RANGE grouping

LabelCfg
Configuration for the labeling engine. All knobs live here.
Fields:
nfeat (series int)
kind (series int)
tgtHigh (series float)
tgtLow (series float)
tgtReject (series float)
qLo (series float)
qHi (series float)
csvSafeMax (series int)
featPrec (series int)
autoResolve (series bool)

LabelStore
Engine state.
Fields:
cfg (LabelCfg)
targets (array<LabTarget>)
samples (array<LabSample>)
pivHigh (array<int>)
pivLow (array<int>)
rangeSeq (series int)

Updated:
method render(self, maxRows)
Namespace types: LabelStore
Parameters:
self (LabelStore)
maxRows (int)

LogRow
Per-bar log entry captured inside the range
Fields:
idx (series int)
hi (series float)
lo (series float)
body (series string)

Inspector
Inspector state container
Fields:
active (series bool)
rangeMode (series bool)
tgTime (series int)
tgTime2 (series int)
atr (series float)
title (series string)
names (array<string>)
vals (array<string>)
rows (array<LogRow>)

Release Notes

v10

Added:
mem_array_int(a)
Count memory units for array<int>
Parameters:
a (array<int>): Array to measure
Returns: int Number of memory units (1 per element)

mem_array_float(a)
Count memory units for array<float>
Parameters:
a (array<float>): Array to measure
Returns: int Number of memory units (1 per element)

mem_array_bool(a)
Count memory units for array<bool>
Parameters:
a (array<bool>): Array to measure
Returns: int Number of memory units (1 per element)

mem_array_string(a)
Count memory units for array<string>
Parameters:
a (array<string>): Array to measure
Returns: int Number of memory units (1 per element)

mem_udt_array(size, fields_per_object, overhead_per_object)
Count memory units for array of UDT objects with overhead
Parameters:
size (int): Array size (use array.size(your_array))
fields_per_object (int): Number of fields in UDT
overhead_per_object (int): Object overhead (default 2 for medium UDT)
Returns: int Total memory units = size × (fields + overhead)
Example type W3LtfBar has 6 fields (o,h,l,c,v,t) + ~2 overhead = 8 units per object
array<W3LtfBar> rqCur with 50 elements = 50 × 8 = 400 units
units = mem_udt_array(array.size(rqCur), 6, 2)

mem_ltfbar_array(size)
Count memory units for array<W3LtfBar> (6 fields + 2 overhead = 8)
Parameters:
size (int): Array size
Returns: int Memory units (size × 8)

mem_liqbar_array(size)
Count memory units for array<W3LiqBar> (2 fields + 1 overhead = 3)
Parameters:
size (int): Array size
Returns: int Memory units (size × 3)

mem_map_int_float(m)
Count memory units for map<int, float>
Parameters:
m (map<int, float>): Map to measure
Returns: int Memory units (size × 2, key + value per entry)

mem_map_int_int(m)
Count memory units for map<int, int>
Parameters:
m (map<int, int>): Map to measure
Returns: int Memory units (size × 2, key + value per entry)

mem_map_string_float(m)
Count memory units for map<string, float>
Parameters:
m (map<string, float>): Map to measure
Returns: int Memory units (size × 2, key + value per entry)

mem_map_generic(size)
Count memory units for any map (generic)
Parameters:
size (int): Map size (use map.size(your_map))
Returns: int Memory units (size × 2, key + value per entry)

mem_array_of_arrays(container_size, inner_units_total)
Count memory units for array of arrays (e.g., array<RollSlot>)
Parameters:
container_size (int): Size of outer array
inner_units_total (int): Total units from all inner arrays (pre-calculated)
Returns: int Total units = container overhead + sum of inner units
Example type RollSlot has 3 arrays: rowId, buy, sell
array<RollSlot> rollSlots with 7 slots
Step 1: Calculate inner units for each slot
int inner_total = 0
for i = 0 to 6
RollSlot s = array.get(rollSlots, i)
inner_total += array.size(s.rowId) + array.size(s.buy) + array.size(s.sell)
Step 2: Add container overhead
units = mem_array_of_arrays(7, inner_total)

mem_bucket_pack(rowId_size, lo_size, hi_size, buy_size, sell_size, liqBuy_size, liqSell_size)
Count memory units for W3BucketPack UDT
Parameters:
rowId_size (int): Size of rowId array
lo_size (int): Size of lo array
hi_size (int): Size of hi array
buy_size (int): Size of buy array
sell_size (int): Size of sell array
liqBuy_size (int): Size of liqBuy array
liqSell_size (int): Size of liqSell array
Returns: int Total units (7 arrays + 5 scalar fields)

mem_rollslot(rowId_size, buy_size, sell_size)
Count memory units for RollSlot UDT
Parameters:
rowId_size (int): Size of rowId array
buy_size (int): Size of buy array
sell_size (int): Size of sell array
Returns: int Total units (3 arrays)

mem_sgd_model(n_features)
Estimate memory units for SGD model (opaque library structure)
Parameters:
n_features (int): Number of features
Returns: int Approximate units (n_features × 4 for weights + gradients + momentum + variance)

mem_scaler_model(n_features)
Estimate memory units for Scaler model (opaque library structure)
Parameters:
n_features (int): Number of features
Returns: int Approximate units (n_features × 2 for min + max per feature)

Release Notes

v11

Added:
mem_footprint_floor(gatedBars, rangePrice, ticksPerRow, liveRows)
Footprint-context floor estimator.
Details request.footprint context is pre-paid across the GATED bar span.
rows/bar = price_range / (ticksPerRow × mintick).
Returns max(model, live_snapshot) so the cell never under-reports.
Parameters:
gatedBars (int): Bars where the if-gate lets footprint allocate (iwarmup + intebars).
rangePrice (float): Price envelope used for row count estimate (scanHi - scanLo).
ticksPerRow (int): fpTicksPerRow actually passed to request.footprint.
liveRows (int): array.size(fp.rows()) on the current bar (0 outside gate is fine).
Returns: int Floor units = max(gated_model, live_snapshot) × 7 fields.

mem_ledger_new()
Create a new empty MemLedger.

method put(m, name, units, note, gated)
Add or update a row by name (idempotent — safe to call every bar).
Namespace types: MemLedger
Parameters:
m (MemLedger): The ledger.
name (string): Row identifier.
units (int): Current memory units.
note (string): Optional detail string (e.g. "27r", "500b").
gated (bool): true = floor-tier consumer.

method seal(m)
Recompute total from all rows. Call once after all puts().
Namespace types: MemLedger
Parameters:
m (MemLedger)

method thief(m)
Return [name, units] of the largest single consumer.
Namespace types: MemLedger
Parameters:
m (MemLedger)

method to_line(m, barIdx)
Serialize ledger to a CSV line for the diag logger.
Details Replaces MEMUNITS + MEMFLOOR log blocks with a single call.
Namespace types: MemLedger
Parameters:
m (MemLedger)
barIdx (int): bar_index to prefix.

method to_table(m, t, startRow, floorCol, featCol)
Render the ledger into a table, replacing all inlined table.cell mem rows.
Namespace types: MemLedger
Parameters:
m (MemLedger): The ledger.
t (table): Target table (must be pre-created by caller).
startRow (int): First row index in the table to write into.
floorCol (color): Color for floor-tier (gated=true) name labels.
featCol (color): Color for feature-tier (gated=false) name labels.

MemRow
One row in the memory ledger: a named consumer with units, peak, and metadata.
Fields:
name (series string): Short name shown in table col 0.
units (series int): Current memory units this tick.
peak (series int): Realtime high-water mark (survives across ticks when MemLedger is var).
note (series string): Capacity / detail text for table col 2.
gated (series bool): true = floor-tier (always-on); false = feature-gated.

MemLedger
Memory ledger: holds a list of MemRows and their summed total.
Fields:
rows (array<MemRow>): Ordered list of MemRow entries.
total (series int): Recomputed by seal() after all puts.

Release Notes

v12

Release Notes

v13

Added:
eff_q(wickExtreme, firePx, closeRef, avgRangePct)
Compute one EffQ sample. Caller pre-computes avgRangePct via ta.sma().
Parameters:
wickExtreme (float): high (upper) or low (lower) of the HTF bar
firePx (float): fire price (the signal entry price)
closeRef (float): close of the HTF bar (normalisation base)
avgRangePct (float): SMA of (high-low)/close*100 over lookback window
Returns: float EffQ in [0,1]; na when inputs unavailable

eff_range_pct(hi, lo, cl)
Compute the avgRangePct series term (range-pct of this bar).
Details Feed result into ta.sma(rangePct, iEffLen) in the caller.
Parameters:
hi (float)
lo (float)
cl (float)
Returns: float (high-low)/close*100; na when close is 0

eff_len(targetHours, minLen)
Compute time-equivalent SMA length for a target horizon in hours.
Parameters:
targetHours (simple int): Desired lookback in hours (e.g. 48)
minLen (simple int): Minimum length guard (default 5)
Returns: int iEffLen = max(minLen, round(targetHours * 60 / tfMinutes))

Updated:
MemLedger
Memory ledger: holds a list of MemRows, their summed total, and an
Fields:
rows (array<MemRow>): Ordered list of MemRow entries.
total (series int): Recomputed by seal() after all puts.
_tbl (series table): Internal table handle for render(). na until first render() call.

Release Notes

v14

Added:
f_struct_log_begin(lg, tag)
Parameters:
lg (Logger)
tag (string)

method field(sl, name, val)
Namespace types: StructLog
Parameters:
sl (StructLog)
name (string)
val (string)

StructLog
StructLog — builder for structured log lines with field accumulation
Fields:
lg (Logger)
tag (series string)
parts (array<string>)

Updated:
method commit(sl)
Namespace types: StructLog
Parameters:
sl (StructLog)

MemLedger
Memory ledger: holds a list of MemRows and their summed total.
Fields:
rows (array<MemRow>): Ordered list of MemRow entries.
total (series int): Recomputed by seal() after all puts.

Removed:
eff_q(wickExtreme, firePx, closeRef, avgRangePct)
Compute one EffQ sample. Caller pre-computes avgRangePct via ta.sma().

eff_range_pct(hi, lo, cl)
Compute the avgRangePct series term (range-pct of this bar).
Details Feed result into ta.sma(rangePct, iEffLen) in the caller.

eff_len(targetHours, minLen)
Compute time-equivalent SMA length for a target horizon in hours.

Release Notes

v15

Added:
f_diag_avg_r2(r1, r2, r3, r4)
Parameters:
r1 (float)
r2 (float)
r3 (float)
r4 (float)

f_diag_best_name(r1, r2, r3, r4)
Parameters:
r1 (float)
r2 (float)
r3 (float)
r4 (float)

f_diag_best_abs(r1, r2, r3, r4)
Parameters:
r1 (float)
r2 (float)
r3 (float)
r4 (float)

f_diag_pct(v)
Parameters:
v (float)

f_diag_num(v)
Parameters:
v (float)

f_diag_r_with_r2(v)
Parameters:
v (float)

f_diag_r2_bg(v)
Parameters:
v (float)

f_diag_pop_bg(v, expected)
Parameters:
v (float)
expected (float)

f_diag_dist_bg(v)
Parameters:
v (float)

Release Notes

v16

Added:
f_float_array_text(values, count, format, prefix, separator, suffix)
Parameters:
values (array<float>)
count (int)
format (string)
prefix (string)
separator (string)
suffix (string)

Pine library

In true TradingView spirit, the author has published this Pine code as an open-source library so that other Pine programmers from our community can reuse it. Cheers to the author! You may use this library privately or in other open-source publications, but reuse of this code in publications is governed by House Rules.

cybermediaboy

Disclaimer

The information and publications are not meant to be, and do not constitute, financial, investment, trading, or other types of advice or recommendations supplied or endorsed by TradingView. Read more in the Terms of Use.

Pine library

cybermediaboy