Logging cleanup

Author: addshore

src/devices/base.toit

@@ -2,6 +2,7 @@ import i2c
 import gpio
 import uart
 import io
+import log
 import .i2c
 
 /*
@@ -37,12 +38,14 @@ abstract class LightbugDevice implements Device:
   i2c-writer_ /Writer
 
   name_ /string
+  logger_ /log.Logger
 
-  constructor name/string i2c-sda/int=I2C-SDA i2c-scl/int=I2C-SCL:
+  constructor name/string i2c-sda/int=I2C-SDA i2c-scl/int=I2C-SCL --logger/log.Logger=(log.default.with-name "lb-device"):
     name_ = name
+    logger_ = logger
     i2c-device_ = LBI2CDevice --sda=i2c-sda --scl=i2c-scl
-    i2c-reader_ = Reader i2c-device_
-    i2c-writer_ = Writer i2c-device_
+    i2c-reader_ = Reader i2c-device_ --logger=logger_
+    i2c-writer_ = Writer i2c-device_ --logger=logger_
 
   name -> string:
     return name_

src/devices/fake.toit

@@ -20,7 +20,6 @@ class FakeReader extends io.Reader with io.InMixin:
   constructor:
 
   read_ -> ByteArray?:
-      // log.debug "FakeReader: Simulating read operation"
       return #[]
 
 class FakeWriter extends io.Writer with io.OutMixin:

src/devices/i2c.toit

@@ -21,27 +21,29 @@ LBI2CDevice --sda/int --scl/int -> i2c.Device:
 class Reader extends io.Reader:
   device /i2c.Device
   finishWhenEmpty_ /bool
+  logger_ /log.Logger
 
-  constructor .device --finishWhenEmpty=false:
+  constructor .device --finishWhenEmpty=false --logger/log.Logger:
     // XXX: --finishWhenEmpty is not used since factoring out into the lightbug package
     // TODO: Decide if we want to keep it, refactor it, or remove it...
     finishWhenEmpty_ = finishWhenEmpty
+    logger_ = logger
 
   /**
   Reads the next bytes.
   There are no yields in this function, so it will block until there are bytes to read,
   as we want to empty the buffer as soon as possible into our own memory.
   */
   read_ -> ByteArray?:
-    // log.debug "calling read_ in LB Reader for i2c"
+    // logger_.debug "calling read_ in LB Reader for i2c"
     all := #[]
     all-expected := 0
     loops := 0
     // Read from the buffer as fast as possible (as our buffer is bigger)
     // At most 5*(tx buffer), so 5*1000 = 5KB
     while loops <= 5:
       loops++
-      // log.debug "Getting number of bytes available to read, loop $loops"
+      // logger_.debug "Getting number of bytes available to read, loop $loops"
       len-bytes := device.read-address #[I2C-COMMAND-LIGHTBUG-READABLE-BYTES] 2
       len-int := LITTLE-ENDIAN.uint16 len-bytes 0
       all-expected = all-expected + len-int
@@ -50,39 +52,41 @@ class Reader extends io.Reader:
       // uart does this with a read state, for now we will just sleep a bit...
       if len-int == 0:
         if finishWhenEmpty_:
-          log.debug "No bytes to read, finishing"
+          logger_.debug "No bytes to read, finishing"
           return null
-        // log.debug "No bytes to read, yielding"
+        // logger_.debug "No bytes to read, yielding"
         break // Leave the while loop
 
-      log.debug "Got $len-int bytes to read"
+      logger_.debug "Got $len-int bytes to read"
 
       while len-int > 0:
         chunkSize := min len-int 254
-        log.debug "Reading chunk of $chunkSize bytes stage 1"
+        logger_.debug "Reading chunk of $chunkSize bytes stage 1"
         device.write #[I2C-COMMAND-LIGHTBUG-READ, chunkSize]
-        log.debug "Reading chunk of $chunkSize bytes stage 2"
+        logger_.debug "Reading chunk of $chunkSize bytes stage 2"
         b := device.read chunkSize
         if b.size != chunkSize:
-          log.error "Failed to read chunk $chunkSize bytes, got $b.size bytes"
+          logger_.error "Failed to read chunk $chunkSize bytes, got $b.size bytes"
           return null
         all += b
         len-int -= chunkSize
 
       if all.size != all-expected:
-        log.error "Failed to read $all-expected bytes, got $all.size bytes"
+        logger_.error "Failed to read $all-expected bytes, got $all.size bytes"
         return null
 
-      log.debug "Read $all.size bytes after $loops loops"
+      logger_.debug "Read $all.size bytes after $loops loops"
 
     yield // They are in our buffer now, so yield briefly before returning
     return all
 
 class Writer extends io.Writer:
   device /i2c.Device
   can-write-bytes /int := 0
+  logger_ /log.Logger
 
-  constructor .device:
+  constructor .device --logger/log.Logger:
+    logger_ = logger
 
   /**
   Writes the given $data to this writer.
@@ -97,21 +101,21 @@ class Writer extends io.Writer:
       bytes = ByteArray.from data
 
     bytes-in-window := to - from
-    log.debug "Going to write $bytes-in-window bytes"
-    log.debug "Bytes: $bytes"
+    logger_.debug "Going to write $bytes-in-window bytes"
+    logger_.debug "Bytes: $bytes"
 
     // Check the receiver has enough space for our bytes before sending...
     // TODO could refactor this to send in smaller chunks if needed?!
     while can-write-bytes == 0:
-      log.debug "Updating or waiting for writeable bytes"
+      logger_.debug "Updating or waiting for writeable bytes"
       len-bytes := device.read-address #[I2C-COMMAND-LIGHTBUG-WRITEABLE_BYTES] 2
       can-write-bytes = LITTLE-ENDIAN.uint16 len-bytes 0
-      log.debug "Can write $can-write-bytes bytes"
+      logger_.debug "Can write $can-write-bytes bytes"
       if can-write-bytes == 0:
-        log.debug "Waiting for some bytes to be writeable"
+        logger_.debug "Waiting for some bytes to be writeable"
         sleep (Duration --ms=50)
       else:
-        log.debug "Can write $can-write-bytes bytes, continuing"
+        logger_.debug "Can write $can-write-bytes bytes, continuing"
 
     current-index := from
     read-to-index := 0
@@ -121,14 +125,14 @@ class Writer extends io.Writer:
       writing := min (to - current-index) (min can-write-bytes 255)
       read-to-index = current-index + writing
 
-      log.debug "Writing bytes $current-index to $read-to-index, $writing bytes"
-      log.debug "Bytes: $bytes[current-index..read-to-index]"
+      logger_.debug "Writing bytes $current-index to $read-to-index, $writing bytes"
+      logger_.debug "Bytes: $bytes[current-index..read-to-index]"
       send-len := #[0]
       LITTLE-ENDIAN.put-uint8 send-len 0 writing
       device.write-address #[I2C-COMMAND-LIGHTBUG-WRITE] send-len + bytes[current-index..read-to-index]
       written += writing
       can-write-bytes -= writing
       current-index = read-to-index
 
-    log.debug "Wrote $written bytes"
+    logger_.debug "Wrote $written bytes"
     return written

src/protocol/data.toit

@@ -19,57 +19,47 @@ class Data:
     if bytes.size < 2:
       throw "V3 OUT_OF_BOUNDS: Not enough bytes to read fields, expected 2 bytes but only have " + bytes.size.stringify
     fields := (bytes[1] << 8) + bytes[0]
-    // log.debug "Data fields: " + fields.stringify
     if bytes.size < 2 + fields:
       throw "V3 OUT_OF_BOUNDS: Not enough bytes to read data types, expected " + (2 + fields).stringify + " bytes but only have " + bytes.size.stringify
     // read data types
     for i := 0; i < fields; i++:
       dataType := bytes[2 + i]
       dataTypes_.add dataType
-      // log.debug "Data data type: " + dataType.stringify
     // read data (each is a uint8 length, then that number of bytes)
     index := 2 + fields
     for i := 0; i < fields; i++:
       if index >= bytes.size:
         throw "V3 OUT_OF_BOUNDS: Not enough bytes to read data length, expected " + index.stringify + " bytes but only have " + bytes.size.stringify
       length := bytes[index]
-      // log.debug "Data data length: " + length.stringify
       index += 1
       if index + length > bytes.size:
         throw "V3 OUT_OF_BOUNDS: Not enough bytes to read data, expected " + (index + length).stringify + " bytes but only have " + bytes.size.stringify
       index += length
-      // log.debug "Data data bytes: " + bytes[index - length..index].stringify
       dataField := DataField (list-to-byte-array bytes[index - length..index])
       data_.add dataField
-      // log.debug "Data data: " + dataField.stringify
 
   constructor.from-bytes bytes/ByteArray:
     if bytes.size < 2:
       throw "V3 OUT_OF_BOUNDS: Not enough bytes to read fields, expected 2 bytes but only have " + bytes.size.stringify
     fields := LITTLE-ENDIAN.uint16 bytes 0
-    // log.debug "Data fields: " + fields.stringify
     if bytes.size < 2 + fields:
       throw "V3 OUT_OF_BOUNDS: Not enough bytes to read data types, expected " + (2 + fields).stringify + " bytes but only have " + bytes.size.stringify
     // read data types
     for i := 0; i < fields; i++:
       dataType := bytes[2 + i]
       dataTypes_.add dataType
-      // log.debug "Data data type: " + dataType.stringify
     // read data (each is a uint8 length, then that number of bytes)
     index := 2 + fields
     for i := 0; i < fields; i++:
       if index >= bytes.size:
         throw "V3 OUT_OF_BOUNDS: Not enough bytes to read data length, expected " + index.stringify + " bytes but only have " + bytes.size.stringify
       length := bytes[index]
-      // log.debug "Data data length: " + length.stringify
       index += 1
       if index + length > bytes.size:
         throw "V3 OUT_OF_BOUNDS: Not enough bytes to read data, expected " + (index + length).stringify + " bytes but only have " + bytes.size.stringify
       index += length
-      // log.debug "Data data bytes: " + bytes[index - length..index].stringify
       dataField := DataField (bytes[index - length..index])
       data_.add dataField
-      // log.debug "Data data: " + dataField.stringify
 
   stringify -> string:
     s := ""
@@ -113,7 +103,7 @@ class Data:
     else if data < 1099511627776:
       add-data-uint64 dataType data
     else:
-      log.error "Data too large for uintn: " + data.stringify
+      log.error "Data too large for uintn: $(data)"
 
   add-data-float32 dataType/int data/float -> none:
     b := #[0,0,0,0]
@@ -135,7 +125,7 @@ class Data:
           return true
       return false
     if e:
-      log.warn "Failed to check for data: " + e.stringify
+      log.warn "Failed to check for data: $(e)"
     return false
 
   remove-data dataType/int -> none:
@@ -146,7 +136,7 @@ class Data:
           data_.remove --at=i
           return
     if e:
-      log.warn "Failed to remove data: " + e.stringify
+      log.warn "Failed to remove data: $(e)"
 
   // returns the data for the type, or an empty list if not found
   // will never throw an error
@@ -157,7 +147,7 @@ class Data:
           return data_[i].dataBytes_
       return #[]
     if e:
-      log.warn "Failed to get data: " + e.stringify
+      log.warn "Failed to get data: $(e)"
     return #[]
 
   get-data-ascii dataType/int -> string:
@@ -168,7 +158,7 @@ class Data:
     // TODO use LITTLE-ENDIAN? (When we have a byte array not a list?)
     data := get-data dataType
     if data.size == 0:
-      log.warn "No data for datatype " + dataType.stringify
+      log.warn "No data for datatype $(dataType)"
       return 0
     return data[0]
 
@@ -184,7 +174,7 @@ class Data:
   get-data-uint64 dataType/int -> int:
     data := get-data dataType
     if data.size < 8:
-      log.warn "No data for datatype " + dataType.stringify
+      log.warn "No data for datatype $(dataType)"
       return 0
     return (data[7] << 56) + (data[6] << 48) + (data[5] << 40) + (data[4] << 32) + (data[3] << 24) + (data[2] << 16) + (data[1] << 8) + data[0]
 
@@ -197,7 +187,7 @@ class Data:
   get-data-list-uint16 dataType/int -> List:
     data := get-data dataType
     if data.size % 2 != 0:
-      log.error "Data size not a multiple of 2 for datatype " + dataType.stringify
+      log.error "Data size not a multiple of 2 for datatype $(dataType)"
       return []
     l := []
     for i := 0; i < data.size; i += 2:
@@ -219,7 +209,7 @@ class Data:
   get-data-list-uint32 dataType/int -> List:
     data := get-data dataType
     if data.size % 4 != 0:
-      log.error "Data size not a multiple of 4 for datatype " + dataType.stringify
+      log.error "Data size not a multiple of 4 for datatype $(dataType)"
       return []
     l := []
     for i := 0; i < data.size; i += 4:
@@ -236,7 +226,7 @@ class Data:
   get-data-list-int32-pairs dataType/int -> List:
     data := get-data dataType
     if data.size % 8 != 0:
-      log.error "Data size not a multiple of 8 for datatype " + dataType.stringify
+      log.error "Data size not a multiple of 8 for datatype $(dataType)"
       return []
     l := []
     for i := 0; i < data.size; i += 8:
@@ -246,7 +236,7 @@ class Data:
   get-data-list-coordinates dataType/int -> List:
     data := get-data dataType
     if data.size % 8 != 0:
-      log.error "Data size not a multiple of 8 for datatype " + dataType.stringify
+      log.error "Data size not a multiple of 8 for datatype $(dataType)"
       return []
     l := []
     for i := 0; i < data.size; i += 8:
@@ -266,7 +256,7 @@ class Data:
     // etc
     data := get-data dataType
     if data.size == 0:
-      log.warn "No data for datatype " + dataType.stringify
+      log.warn "No data for datatype $(dataType)"
       return 0
     if data.size == 1:
       return LITTLE-ENDIAN.uint8 data 0
@@ -285,7 +275,7 @@ class Data:
     if data.size == 8:
         // toit doesnt actually support uint64, so this will always be represented as int64
         return (data[7] << 56) + (data[6] << 48) + (data[5] << 40) + (data[4] << 32) + (data[3] << 24) + (data[2] << 16) + (data[1] << 8) + data[0]
-    log.error "Data size too large for uintn: " + data.size.stringify
+    log.error "Data size too large for uintn: $(data.size)"
     return 0
 
   get-data-intn dataType/int -> int:
@@ -296,7 +286,7 @@ class Data:
     // etc
     data := get-data dataType
     if data.size == 0:
-        log.warn "No data for datatype " + dataType.stringify
+        log.warn "No data for datatype $(dataType)"
         return 0
     if data.size == 1:
         return LITTLE-ENDIAN.int8 data 0
@@ -315,7 +305,7 @@ class Data:
     if data.size == 8:
             // toit doesnt actually support int64, so this will always be represented as int64
             return (data[7] << 56) + (data[6] << 48) + (data[5] << 40) + (data[4] << 32) + (data[3] << 24) + (data[2] << 16) + (data[1] << 8) + data[0]
-    log.error "Data size too large for intn: " + data.size.stringify
+    log.error "Data size too large for intn: $(data.size)"
     return 0
 
   size -> int: