Fix unstable/logging to work with the new logging system.

collects/tests/unstable/logging.rkt

@@ -5,7 +5,7 @@
 (run-tests
  (test-suite "logging.rkt"
    (test-case "start/stop-recording"
-     (let ([l (start-recording #:level 'warning)])
+     (let ([l (start-recording 'warning)])
        (log-warning "1")
        (log-warning "2")
        (log-warning "3")

collects/unstable/logging.rkt

@@ -3,6 +3,7 @@
 (require racket/contract/base)
 
 (define level/c (or/c 'fatal 'error 'warning 'info 'debug))
+(define log-spec/c (listof (or/c symbol? #f)))
 (define log-message/c (vector/c level/c string? any/c))
 
 ;; helper used below
@@ -33,8 +34,8 @@
                   [done? #:mutable]))
 
 ;; [level] -> listener
-(define (start-recording #:level [level 'debug])
+(define (start-recording . log-spec)
-  (let* ([receiver     (make-log-receiver (current-logger) level)]
+  (let* ([receiver     (apply make-log-receiver (current-logger) log-spec)]
          [stop-chan    (make-channel)]
          [cur-listener (listener stop-chan #f '() #f)]
          [t (receiver-thread
@@ -56,45 +57,38 @@
   (reverse (listener-rev-messages cur-listener)))
 
 (provide/contract
- [start-recording (->* () (#:level level/c) listener?)]
+ [start-recording (->* () #:rest log-spec/c listener?)]
  [stop-recording  (-> listener? (listof log-message/c))])
 
 
-(define (with-intercepted-logging interceptor proc #:level [level 'debug])
+(define (with-intercepted-logging interceptor proc . log-spec)
   (let* ([orig-logger (current-logger)]
-         ;; the new logger is unrelated to the original, to avoid getting
+         ;; We use a local logger to avoid getting messages that didn't
-         ;; messages sent to it that didn't originate from proc
+         ;; originate from proc. Since it's a child of the original logger,
-         [logger      (make-logger)]
+         ;; the rest of the program still sees the log entries.
-         [receiver    (make-log-receiver logger level)]
+         [logger      (make-logger #f orig-logger)]
+         [receiver    (apply make-log-receiver logger log-spec)]
          [stop-chan   (make-channel)]
-         [t (receiver-thread
+         [t           (receiver-thread receiver stop-chan interceptor)])
-             receiver stop-chan
-             (lambda (l)
-               ;; we want to send l to the original logger, so that
-               ;; the rest of the system can see it too.
-               (log-message orig-logger
-                            (vector-ref l 0)  ; level
-                            (vector-ref l 1)  ; message
-                            (vector-ref l 2)) ; data
-               (interceptor l)))])
     (begin0
         (parameterize ([current-logger logger])
           (proc))
       (channel-put stop-chan 'stop) ; stop the receiver thread
       (thread-wait t))))
 
-(define (with-logging-to-port port proc #:level [level 'debug])
+(define (with-logging-to-port port proc . log-spec)
-  (with-intercepted-logging
+  (apply with-intercepted-logging
-   (lambda (l) (displayln (vector-ref l 1) ; actual message
+         (lambda (l) (displayln (vector-ref l 1) ; actual message
-                          port))
+                                port))
-   proc #:level level))
+         proc
+         log-spec))
 
 (provide/contract [with-intercepted-logging
                    (->* ((-> log-message/c any)
                          (-> any))
-                        (#:level level/c)
+                        #:rest log-spec/c
                         any)]
                   [with-logging-to-port
                    (->* (output-port? (-> any))
-                        (#:level level/c)
+                        #:rest log-spec/c
                         any)])

collects/unstable/scribblings/logging.scrbl

@@ -13,11 +13,12 @@ This module provides tools for logging.
 
 @defproc[(with-logging-to-port
            [port output-port?] [proc (-> any)]
-           [#:level level (or/c 'fatal 'error 'warning 'info 'debug) 'debug])
+	   [log-spec (or/c 'fatal 'error 'warning 'info 'debug symbol? #f)] ...)
          any]{
 
-Runs @racket[proc], outputting any logging of level @racket[level] or higher to
+Runs @racket[proc], outputting any logging that would be received by
-@racket[port]. Returns whatever @racket[proc] returns.
+@racket[(make-log-receiver (current-logger) log-spec ...)] to @racket[port].
+Returns whatever @racket[proc] returns.
 
 @defexamples[
 #:eval the-eval
@@ -26,22 +27,23 @@ Runs @racket[proc], outputting any logging of level @racket[level] or higher to
     (lambda ()
       (log-warning "Warning World!")
       (+ 2 2))
-    #:level 'warning)
+    'warning)
   (get-output-string my-log))]}
 
 
 @defproc[(with-intercepted-logging
            [interceptor (-> (vector/c
-	                      (or/c 'fatal 'error 'warning 'info 'debug)
+                              (or/c 'fatal 'error 'warning 'info 'debug)
-	                      string?
+                              string?
 			      any/c)
 			     any)]
            [proc (-> any)]
-           [#:level level (or/c 'fatal 'error 'warning 'info 'debug) 'debug])
+           [log-spec (or/c 'fatal 'error 'warning 'info 'debug symbol? #f)] ...)
          any]{
 
-Runs @racket[proc], calling @racket[interceptor] on any log message of level
+Runs @racket[proc], calling @racket[interceptor] on any log message that would
-@racket[level] or higher. @racket[interceptor] receives the entire log vectors
+be received by @racket[(make-log-receiver (current-logger) log-spec ...)].
+@racket[interceptor] receives the entire log vectors
 (see @secref["receiving-logged-events" #:doc '(lib "scribblings/reference/reference.scrbl")])
 as arguments. Returns whatever @racket[proc] returns.
 
@@ -57,7 +59,7 @@ as arguments. Returns whatever @racket[proc] returns.
       (log-warning "Warning!")
       (log-warning "Warning again!")
       (+ 2 2))
-    #:level 'warning)
+    'warning)
   warning-counter)]}
 
 
@@ -65,21 +67,21 @@ A lower-level interface to logging is also available.
 
 @deftogether[[
   @defproc[(start-recording
-            [#:level level (or/c 'fatal 'error 'warning 'info 'debug) 'debug])
+            [log-spec (or/c 'fatal 'error 'warning 'info 'debug symbol? #f)] ...)
            listener?]
   @defproc[(stop-recording [listener listener?])
            (listof (vector/c (or/c 'fatal 'error 'warning 'info 'debug)
                              string?
                              any/c))]]]{
 
-@racket[start-recording] starts recording log messages of the desired level or
+@racket[start-recording] starts recording log messages matching the given
-higher. Messages will be recorded until stopped by passing the returned
+@racket[log-spec]. Messages will be recorded until stopped by passing the
-listener object to @racket[stop-recording]. @racket[stop-recording] will then
+returned listener object to @racket[stop-recording]. @racket[stop-recording]
-return a list of the log messages that have been reported.
+will then return a list of the log messages that have been reported.
 
 @defexamples[
 #:eval the-eval
-(define l (start-recording #:level 'warning))
+(define l (start-recording 'warning))
 (log-warning "1")
 (log-warning "2")
 (stop-recording l)