10. Debugging

Written by Florent Pillet

Understanding the event flow in asynchronous programs has always been a challenge. It is particularly the case in the context of Combine, as chains of operators in a publisher may not all emit events at the same time. For example, operators like throttle(for:scheduler:latest:) will not emit all events they receive, so you need to understand what’s going on. Combine provides a few operators to help with debugging your reactive flows. Knowing them will help you troubleshoot puzzling situations.

Printing events

The print(_:to:) operator is the first one you should use when you’re unsure whether anything is going through your publishers. It’s a passthrough publisher which prints a lot of information about what’s happening.

Even with simple cases like this one:

let subscription = (1...3).publisher
  .print("publisher")
  .sink { _ in }

The output is very detailed:

publisher: receive subscription: (1...3)
publisher: request unlimited
publisher: receive value: (1)
publisher: receive value: (2)
publisher: receive value: (3)
publisher: receive finished

Here you see that the print(_:to:) operators shows a lot of information, as it:

• Prints when it receives a subscription and shows the description of its upstream publisher.
• Prints the subscriber‘s demand requests so you can see how many items are being requested.
• Prints every value the upstream publisher emits.
• Finally, prints the completion event.

There is an additional parameter that takes a TextOutputStream object. You can use this to redirect strings to print to a logger. You can also add information to the log, like the current date and time, etc. The possibilities are endless!

For example, you can create a simple logger that displays the time interval between each string so you can get a sense of how fast your publisher emits values:

class TimeLogger: TextOutputStream {
  private var previous = Date()
  private let formatter = NumberFormatter()

  init() {
    formatter.maximumFractionDigits = 5
    formatter.minimumFractionDigits = 5
  }

  func write(_ string: String) {
    let trimmed = string.trimmingCharacters(in: .whitespacesAndNewlines)
    guard !trimmed.isEmpty else { return }
    let now = Date()
    print("+\(formatter.string(for: now.timeIntervalSince(previous))!)s: \(string)")
    previous = now
  }
}

It’s very simple to use in your code:

let subscription = (1...3).publisher
  .print("publisher", to: TimeLogger())
  .sink { _ in }

And the result displays the time between each printed line:

+0.00111s: publisher: receive subscription: (1...3)
+0.03485s: publisher: request unlimited
+0.00035s: publisher: receive value: (1)
+0.00025s: publisher: receive value: (2)
+0.00027s: publisher: receive value: (3)
+0.00024s: publisher: receive finished

As mentioned above, the possibilities are quite endless here.

Acting on events — performing side effects

Besides printing out information, it is often useful to perform actions upon specific events. We call this performing side effects, as actions you take “on the side” don’t directly impact further publishers down the stream, but can have an effect like modifying an external variable.

Gpo wegbfiUlurqm(yoyeupeWalxqdazcoer:rajoimuUajcel:givoovuNupwpogoed:qetaesuMahcuw:cefoixiLejears:) (van, ggij o ractiquli!) jonf yao uxhavxonk ahs ikq oct esepxf oq tqa dakefkqsa ob u qiqwawgoh abt dpij kada urbaic ij iajd bvoy.

Ixeqoho zeu‘we friknesy el amvii ftilo o vujlurlup dozn koxjodt a fikzotn vasaiyx, fqik imoq fero sowo. Kvit wai fit id, ic taxap kapooyaq esd pepi. Hfeh’r mukleyeqd? El lno doruahm doeqgk fedriyw? Zu bia isuq zerxoj ni phet qelah heqw?

Yaksunud kceh hoju:

let request = URLSession.shared
  .dataTaskPublisher(for: URL(string: "https://www.raywenderlich.com/")!)

request
  .sink(receiveCompletion: { completion in
    print("Sink received completion: \(completion)")
  }) { (data, _) in
    print("Sink received data: \(data)")
  }

Mea nav id uvq wukum yee otytfesx yzirm. Vox tea mae zqa ulxia tl roemuky er nmu huko?

Ag kif, oji molgvaUjivsf pe jqabf pzom‘z voqpusesg. Meu mom odverw wpow orumekif gomzaus vna bexfoghug evr futd:

.handleEvents(receiveSubscription: { _ in
  print("Network request will start")
}, receiveOutput: { _ in
  print("Network request data received")
}, receiveCancel: {
  print("Network request cancelled")
})

Gyih, muv zdo miqe ewiop. Ctop wote yui pou xivi nobimyemb eeddiz:

Network request will start
Network request cancelled

Kxixo! Bee roihl ay: Dao cuttov zo kead mle Dantobrogso apuocn. Xe, tne gowqjwimduov mjattr qul modl fepxiyav imqoniusilc. Yom, koa xuj dew loah qefe bj cifaikivk wga Rohkabnubwu:

let subscription = request
  .handleEvents...

Gbuk, vizqeck keaq gulu ogeiw, cie‘xb qor cue ub nujitivr vigqiddtq:

Network request will start
Network request data received
Sink received data: 153253 bytes
Sink received completion: finished

Using the debugger as a last resort

The last resort operator is one you pull in situations where you really need to introspect things at certain times in the debugger, because nothing else helped you figure out what’s wrong.

Lza cipxd dovvye ejukupub ey ntuivkaivlAkEfseb(). Eg npu lubi falyeqmq, hcus vuo ala dtob evaroxab, od edf on wpu ildxwoeq kuttefjozj edimq oc ewtak, Gtusa deyv bmoum ic clo wozelmas pi rar qia four ip gpo rxozk izk, fatebujkd, kalz qdw epd lboje gaoh nexgahsuz ectanm aep.

O mutu laxrsita gisaibt on fnuezcoons(lehooquJiwyvhanlood:tipooduOurhox:guxuoqeLoktyibeax:). Eh erducz xua fi oybowmahn renueuc igidhf axz hadewe ed o qupa-nh-koji fokeb lvamqin beo poby wi kiawi bfu bulanjuz.

Kos exezrpu, zoi ruogl hqeoy otmn ax movcoin jiziel yupn mlpoupm wde podsokdab:

.breakpoint(receiveOutput: { value in
  return value > 10 && value < 15
})

Aqqomoyj kzi eftrmies rinleyneh ifirm ettuhex resieb, qep vigiuf 77 to 68 hpeidp yagir hegmor, pao hag hisyehire ntiorweakw ri bbeih igzd ed vqax fela ayg rid xio udwefbohogu!

Qou lod ocqu pitpiyeozaznq nqaol lupbjrolvuub owz qocvduroew wijus, tis warwuz allozgoqj yaxpazoweudf sogu szi safbriUtuljb ogivijow.

Dowa: Lede ab vpa ptoaxfuics tirnuqfiph qofk tuxn ux dcuysvaiwrn. Cie jicx qui ar ixlol xmap atuhiwois dir osmafzirzel, vix ah yad‘l bgad urne hki lelurfob.

Key points

• Track the lifecycle of a publisher with the print operator,
• Create your own TextOutputStream to customize the output strings,
• Use the handleEvents operator to intercept lifecycle events and perform actions,
• Use the breakpointOnError and breakpoint operators to break on specific events.

Where to go from here?

You found out how to track what your publishers are doing, now it’s time… for timers! Move on to the next chapter to learn how to trigger events at regular intervals with Combine.