nim-dagger/codex/units.nim
Eric de88fd2c53
feat: create logging proxy (#663)
* implement a logging proxy

The logging proxy:
- prevents the need to import chronicles (as well as export except toJson),
- prevents the need to override `writeValue` or use or import nim-json-seralization elsewhere in the codebase, allowing for sole use of utils/json for de/serialization,
- and handles json formatting correctly in chronicles json sinks

* Rename logging -> logutils to avoid ambiguity with common names

* clean up

* add setProperty for JsonRecord, remove nim-json-serialization conflict

* Allow specifying textlines and json format separately

Not specifying a LogFormat will apply the formatting to both textlines and json sinks.

Specifying a LogFormat will apply the formatting to only that sink.

* remove unneeded usages of std/json

We only need to import utils/json instead of std/json

* move serialization from rest/json to utils/json so it can be shared

* fix NoColors ambiguity

Was causing unit tests to fail on Windows.

* Remove nre usage to fix Windows error

Windows was erroring with `could not load: pcre64.dll`. Instead of fixing that error, remove the pcre usage :)

* Add logutils module doc

* Shorten logutils.formatIt for `NBytes`

Both json and textlines formatIt were not needed, and could be combined into one formatIt

* remove debug integration test config

debug output and logformat of json for integration test logs

* Use ## module doc to support docgen

* bump nim-poseidon2 to export fromBytes

Before the changes in this branch, fromBytes was likely being resolved by nim-stew, or other dependency. With the changes in this branch, that dependency was removed and fromBytes could no longer be resolved. By exporting fromBytes from nim-poseidon, the correct resolution is now happening.

* fixes to get compiling after rebasing master

* Add support for Result types being logged using formatIt
2024-01-22 23:35:03 -08:00

74 lines
2.1 KiB
Nim

## Nim-Codex
## Copyright (c) 2023 Status Research & Development GmbH
## Licensed under either of
## * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
## * MIT license ([LICENSE-MIT](LICENSE-MIT))
## at your option.
## This file may not be copied, modified, or distributed except according to
## those terms.
##
import std/hashes
import std/strutils
import pkg/upraises
import ./logutils
type
NBytes* = distinct Natural
template basicMaths(T: untyped) =
proc `+` *(x: T, y: static[int]): T = T(`+`(x.Natural, y.Natural))
proc `-` *(x: T, y: static[int]): T = T(`-`(x.Natural, y.Natural))
proc `*` *(x: T, y: static[int]): T = T(`*`(x.Natural, y.Natural))
proc `+` *(x, y: T): T = T(`+`(x.Natural, y.Natural))
proc `-` *(x, y: T): T = T(`-`(x.Natural, y.Natural))
proc `*` *(x, y: T): T = T(`*`(x.Natural, y.Natural))
proc `<` *(x, y: T): bool {.borrow.}
proc `<=` *(x, y: T): bool {.borrow.}
proc `==` *(x, y: T): bool {.borrow.}
proc `+=` *(x: var T, y: T) {.borrow.}
proc `-=` *(x: var T, y: T) {.borrow.}
proc `hash` *(x: T): Hash {.borrow.}
template divMaths(T: untyped) =
proc `mod` *(x, y: T): T = T(`mod`(x.Natural, y.Natural))
proc `div` *(x, y: T): Natural = `div`(x.Natural, y.Natural)
# proc `/` *(x, y: T): Natural = `/`(x.Natural, y.Natural)
basicMaths(NBytes)
divMaths(NBytes)
proc `$`*(ts: NBytes): string = $(int(ts)) & "'NByte"
proc `'nb`*(n: string): NBytes = parseInt(n).NBytes
logutils.formatIt(NBytes): $it
const
MiB = 1024.NBytes * 1024.NBytes # ByteSz, 1 mebibyte = 1,048,576 ByteSz
proc MiBs*(v: Natural): NBytes = v.NBytes * MiB
func divUp*[T: NBytes](a, b : T): int =
## Division with result rounded up (rather than truncated as in 'div')
assert(b != T(0))
if a==T(0): int(0) else: int( ((a - T(1)) div b) + 1 )
when isMainModule:
import unittest2
suite "maths":
test "basics":
let x = 5.NBytes
let y = 10.NBytes
check x + y == 15.NBytes
expect RangeDefect:
check x - y == 10.NBytes
check y - x == 5.NBytes
check x * y == 50.NBytes
check y div x == 2
check y > x == true
check y <= x == false