Logging for rookies in Swift

Fundamental output in Swift utilizing print

The very first technique I would like to point out you is the print operate. It might write the textual illustration of the given gadgets to the usual output. In different phrases we are able to merely say that it may well print textual content to the display screen. Many of the whats up phrase packages make the most of this technique to show the well-known “Hi there world!” message. In Swift, print is sort of a strong technique, since you’ll be able to go round a number of gadgets for printing out plus you’ll be able to specify a separator string and a terminator parameter. 🤔

print("Hi there World!")

The snippet above will show the Hi there World! textual content adopted by a newline character (n), it’s because the default terminator is all the time a newline. You possibly can override this habits by offering your personal terminator string.

print("Hi there World!", terminator: "")

Should you run this instance utilizing Xcode you must see that the “Program ended with exit code: 0” textual content will seem in a newline within the first case, however within the second situation it’s going to be printed out proper after the “Hi there World!” sentence. Should you run this system utilizing a Terminal software, a % character be current as an alternative of the brand new line within the second case. 💡

What about printing out a number of variables? It’s potential to present a number of gadgets to the print operate, they are often actually something, print can deal with strings, integers and all types of different variables. Print below the hood will convert the variable into a correct string illustration, so you do not have to fiddle with sort casting on a regular basis, however merely print out something.

print(1, 2, 3, 4, 5)


print(1, "two", 3.14, true)

You may as well customise the separator character by means of an argument. So in case you want a coma character (adopted by an area) in between the weather, you’ll be able to write one thing like this:

print("a", "b", "c", separator: ", ")

Nicely, in my earlier article you’ve got seen easy methods to assemble varied strings utilizing literals and interpolation, you should use all these variables to print out stuff to the console.

print("""
            __
           / _)
    .-^^^-/ /
 __/       /
<__.|_|-|_|
""")

For instance, this is a cute multi-line ascii artwork dinosaur. 🦕

Debugging and print

Typically it will be cool to know just a bit bit of additional data concerning the printed variable, that is when debugPrint might help you. The primary distinction between print and debugPrint is that whereas print merely converts every part to string, debug print will provide you with a quick debug data concerning the given gadgets. The debugPrint technique will print out numbers identical to print does, it’s going to add double quotes round strings, and it will print some additional data about many of the different “complicated” varieties.

print(1) 
debugPrint(1) 

print("foo") 
debugPrint("foo") 

print(1...5) 
debugPrint(1...5) 

Truthfully I’ve nearly by no means used this technique, and I all the time most well-liked print if I needed to print out one thing to the console, but it surely’s all the time good to know that there’s such an possibility out there built-in to the usual library, nevertheless there’s a technique that may give you far more data… 🧐

Debugging utilizing dump

The dump technique can print out the given object’s content material utilizing its mirror to the usual output. Lengthy story quick, this operate will present you a extra detailed view concerning the property. For scalar values the dump technique will produce nearly the identical output as debug-print, besides the dump line all the time begins with a touch character, however for extra complicated varieties it’s going to output the underlying construction of the thing. Don’t fret, you needn’t perceive the output of this technique, simply keep in mind that it may well present you useful data throughout debugging. 🐞

dump(1)
dump(3.14)
dump("foo")
dump(1...5)

The ClosedRange struct is a built-in sort with a lowerBound and an upperBound property. Whereas the print operate solely returned the outlined vary (1…5), the debugPrint technique additionally revealed the kind of the thing, dump takes this one step additional by displaying us the precise decrease and higher sure properties of the worth. This may be extraordinarily useful when you’ve got a posh sort with a lot of underlying properties that you just wish to shortly examine for some motive. 🔍

By the way in which, debugging is the act of discovering (and resolving) bugs. Bugs are issues in your program code that stop regular operation. Builders can use debugger instruments to run and examine code step-by-step, line by line or per instruction, however most of them are merely placing print statements into the code to see the present state or results of a given operate. 🤷‍♂️

Dump has a number of extra operate arguments that you may configure:

dump("check", identify: "my-variable", indent: 4, maxDepth: 5, maxItems: 5)

You may give a reputation to every dumped variable, add some additional indentation earlier than the sprint character, specify the utmost depth for descendents and the utmost variety of components for which to put in writing the complete contents. Be at liberty to play with these parameters for some time. 😉

As you’ll be able to see dump is sort of a strong technique, however nonetheless there are different capabilities for logging functions, let me present you one that’s coming from the Goal-C occasions.

NSLog – the legacy logger operate

When you’ve got ever labored with Goal-C you have to be acquainted with the NS prefixes. The NSLog operate can log an error message to the Apple System Log facility console. It is not a part of the Swift customary library, however it’s important to import the Basis framework to be able to use NSLog.

import Basis

NSLog("I am a dinosaur.")

It’s best to know that NSLog will print the present date & time first, then it’s going to show the identify of the operating program with the method and thread identifiers and solely then it’s going to print your message.

Simply to be clear, NSLog is coming from the Goal-C period, it’s not a advisable logging resolution anymore. Additionally it is very sluggish and that may trigger some points in case you want exactly timed outputs. That is why I do NOT advocate utilizing NSLog in any respect, however you additionally must know that till a number of years in the past there was no higher built-in various for it, I am not judging, simply saying… 😅

Unified Logging and Exercise Tracing

If you wish to ship log messages on an Apple machine to the unified logging system, you should use the OSLog framework. This new device was launched at WWDC 2016 and not too long ago obtained some good API refinements & updates. It’s best to undoubtedly test the OSLog and Unified Logging advisable by Apple article if you wish to be taught extra about this subject it is an awesome write up.

My solely concern about this logging API is that it’s not that common. It really works nice on Apple platforms, however since Swift is an common language if you wish to add Linux and even Home windows assist, this resolution will not be just right for you…

SwiftLog – A Logging API bundle for Swift

This open supply bundle may be simply built-in into your Swift tasks through the Swift Bundle Supervisor. You simply must set it up as a dependency within the Bundle.swift manifest file or you’ll be able to hook it utilizing Xcode below the File > Swift Packages menu as an SPM dependency.

import PackageDescription

let bundle = Bundle(
    identify: "myProject",
    dependencies: [
        .package(url: "https://github.com/apple/swift-log.git", from: "1.4.0"),
    ],
    targets: [
        .target(name: "myProject", dependencies: [
            .product(name: "Logging", package: "swift-log")
        ])
    ]
)

The utilization is basically easy. First it’s important to import the Logging framework, then you definately create a logger and you utilize that logger occasion to print out varied log messages.

import Logging

let logger = Logger(label: "app-identifier")

logger.data("Hi there World!")

The next log ranges are supported:

• hint
• debug
• data
• discover
• warning
• error
• important

You may as well connect further logging metadata to the logger, you must test the readme for more information about this feature. SwiftLog is utilized in many real-world tasks, resembling Vapor 4 (a server facet Swift framework), this additionally implies that it really works nice on Linux working methods. 🐧

Conclusion

If it involves logging, there are a number of good choices to select from. It solely will depend on your wants which one is one of the best, however basically we are able to say that it’s time to depart behind NSLog, and time to make use of the brand new OSLog framework. In case you are utilizing Swift on non-Apple platform you must think about using the SwiftLog library, which can also be supplied by Apple.

Alternatively if you’re simply scratching the floor and you do not want that many choices or log ranges you’ll be able to merely keep on with print and dump statements. It is completely advantageous to debug utilizing these easy strategies at first. Mastering one thing takes time and debuggers may be fairly horrifying at first sight. Use print as a lot as you want, however all the time attempt to enhance your instruments & information over time, I hope this text offers you a greater view of the out there logging instruments. 🤓