Skip to main content

durbun 0.3.0 copy "durbun: ^0.3.0" to clipboard
durbun: ^0.3.0 copied to clipboard

Network, log and crash inspector for Flutter apps: an in-app panel on the phone and live streaming to the Dürbün Mac app, with mocks and native capture.

0.3.0 #

  • In-app panel: Tools → Mac connection says why the app is not connected and what to do next (Mac app not open, USB debugging, wrong address, local network connections off on the Mac, iOS Local Network permission), with the addresses tried. A debug build prints the same once in the console.
  • The Mac's Wi-Fi address can be typed in the panel at run time: tried at once, kept for the next launches, Use the build's address goes back. The USB link stays in use.
  • Tools → App tools: your DurbunActions and the built-in Flutter, Android and iOS tools work from the panel, without the Mac.
  • When the SDK has not started or is off in the build, Durbun.showInspector() opens a page that says why and what to do instead of nothing; a debug build says it in the console too.
  • A one-time "Shake the phone to open the Dürbün panel" hint on the first launch (DurbunInspector(showHint: false) turns it off).
  • DurbunNavigatorObserver: each screen change is sent as a navigation event ({from, to}, route names only), the same event the other Dürbün SDKs send. App lifecycle changes arrive as log lines with the tag lifecycle (DurbunOptions(captureLifecycle: false) turns them off).
  • New DurbunOptions.maxBodyBytes (body limit until a desktop connects, at most 10 MB) and DurbunOptions.captureBodies (false: never capture bodies, whatever the desktop asks). The panel shows the body setting in use without a Mac too.
  • Fewer connection attempts while no desktop answers: after two minutes they slow down to about one every 30 seconds, and none are made while the app is in the background. Returning to the app or entering an address tries at once.
  • In-app panel: large bodies (256 KB or more) are prepared in the background instead of freezing the app; the JSON tree opens one level deep and the Code view shows the first 200 KB until Show all.
  • In-app panel: Previous run is listed under Tools even while it is off, with what it does and the line that turns it on. It stays off by default because it writes captured traffic to the phone's storage.
  • In-app panel: the Device & SDK page lists what is not captured (background isolates, dart:developer log(), clients with their own network stack, WebView, WebSocket messages and more) and why.
  • In-app panel: the performance charts follow the screen's refresh rate (for example 120 FPS and 8.3 ms), as the janky frame count already did.
  • In-app panel: in apps in other languages the panel uses English and is laid out left to right, also in right-to-left apps.
  • README: the panel's layout (two tabs and Tools), the web (nothing captured) and desktop platforms are described as they work.
  • In-app panel, new look: one type scale, the selected tab, segment and filter chip filled in the accent colour, and every text readable in light and dark (at least 4.5:1 contrast). Buttons, chips and segments are 44 pt to tap.
  • Request rows are two lines: the status, the method and path with the time on the right, then the host, one badge (error kind, mock, GraphQL operation or client) and the size. A pending request counts up its time. Requests in the log stream use the same row.
  • Log rows name the level as a word ("Error", "Warning") instead of a letter; a crash shows its crash badge.
  • Request detail: the body's find bar opens from a search button next to the view menu, so the page keeps two bars over the body; Expand all and Collapse all are in the view menu.
  • Performance and Statistics lead with one large figure (FPS, request count, median time); a chart with one line no longer repeats its title as a legend.
  • Tools uses plain icons and readable values; empty lists show the Dürbün mark with one line of text; the setup snippets have a copy button in their corner.
  • Landscape and tablets: the panel stops at 720 pt wide, centred, and the floating button stays inside the safe area on every side.
  • The first-launch hint is shorter and closes with Got it.
  • In-app panel, a look of its own in light and dark: a switch in the header keeps your choice; Network, Logs, Performance and Tools are tabs at the bottom (in the header on a short screen); requests and log lines are cards, with tiles for the total, the errors and the average time above the list.
  • WebSocket messages and Server-Sent Events. While the Mac app asks for them, a WebSocket opened with dart:io (WebSocket.connect, IOWebSocketChannel) and every text/event-stream response read through dart:io show their messages under the connection's entry, in order: direction, size, text or binary content up to the Mac app's limit (decoded when compressed), close code and reason, event type, id and retry. A connection that breaks shows the error; an event stream your app stops reading shows as cancelled. Otherwise both are reported exactly as before.
  • New DurbunNetwork.webSocket(...) and DurbunHttpCall.eventStream(...) report WebSockets and event streams that dart:io does not carry (CupertinoWebSocket, Cronet, ok_http); DurbunNetwork.capturesStreams says whether the Mac app takes them. A class that implements DurbunHttpCall needs the new method.
  • On Android and iOS the native cores inside the plugin report OkHttp and URLSession streams too (DurbunWebSocketFactory, URLSessionWebSocketTask).
  • In-app panel: WebSocket and event stream rows show WS/SSE, the state and the message count; the detail opens on Messages (Events), and a message opens on its own page with a masked Share. Works without the Mac for dart:io sockets and streams and DurbunNetwork.webSocket; OkHttp, URLSession and background-isolate connections show their messages while the Mac app records them. The phone keeps up to 500 messages per connection (the first 20 stay), 16 KB of each payload, and 8 MB / 5,000 messages in total.
  • In-app panel: in Statistics the timeouts note sits under the number.
  • In-app panel: Report a bug (Tools, an error or crash line's detail, a failed request's ⋯ menu and Share sheet): pick 30 s to 5 min before the moment (10 s after are always in), see the counts, leave the screenshot out if you like, add a note, and share the text, the full report (.md) and the screenshot (PNG) at once. Secret values are masked by default, in log text too. Works without the Mac.
  • The screenshot is the app as it was just before the panel opened, taken only while Dürbün runs and dropped when the panel closes.
  • Mock rules limited to one GraphQL operation (when.graphql: operation name, optionally query / mutation / subscription) apply on the phone: the operation is read from the JSON body (single or batched), a GraphQL document, or a GET's query / operationName parameters, as the Mac reads it. A body over 64 K characters, or one that is not UTF-8, never matches such a rule. For dart:io requests to a URL with such a rule, the request is sent once its body is written (nothing changes for other requests). The panel's Mocks list shows the operation on the rule.
  • DurbunNetwork.findMock takes the request's contentType and body, so a custom reporter can apply GraphQL rules too.
  • iOS: upload tasks (URLSession.uploadTask) are no longer intercepted by default (the native SDK's new interceptUploadTasks: false); they still run untouched.
  • In-app panel: the session export (report and HAR) and the full file of Report a bug carry the WebSocket messages and SSE events of the connections in them, masked like the rest. The HAR writes them as _webSocketMessages (Chrome DevTools reads them) and _eventSourceMessages, as the Mac's HAR does.

0.2.0 #

  • In-app panel: Send to Slack on the request and log Share sheets posts to your team's channel from the phone itself, without the desktop. The webhook comes from DurbunOptions.slackWebhook or --dart-define=DURBUN_SLACK_WEBHOOK=…; without one there is no Slack button. Keep the URL out of the repository: it is compiled into the build.
  • Log lines can be shared through the system share sheet too.
  • Works with Dürbün 0.2.0 on the Mac (Flows, shared packages, backups).

0.1.0 #

First public release.

  • A Flutter plugin with native Android (Kotlin) and iOS (Swift) layers: one dependency covers Dart, Android and iOS code. Requires Flutter 3.27 / Dart 3.6 or newer.
  • Durbun.run / Durbun.init; logs (log, v/d/i/w/e/f) with tags and structured data, events, print / debugPrint capture, Flutter errors and uncaught errors, native Android and iOS logs.
  • HTTP capture for dart:io (HttpClient, package:http's IOClient, Dio's default adapter, Image.network) with headers, bodies and timings, plus URLSession and OkHttp through the native layers. Dio's native adapters are covered by durbun_dio.
  • Mock rules from the Dürbün desktop app (respond, delay, fail), applied inside the app.
  • Frame, memory and CPU metrics; desktop device commands and custom DurbunAction buttons.
  • In-app inspector (DurbunInspector) that works without a Mac: network list and request details, logs, mocks, performance and device tabs, request comparison, find in bodies, session export and shareable reports. Opens by shaking the phone; English and Turkish.
  • Transport on a background isolate: 127.0.0.1:9751 (adb reverse, simulators), a usbmux listener on iOS devices (127.0.0.1:9752–9755), an optional Wi-Fi host, reconnects with backoff and a bounded buffer.
  • On in debug and profile builds; in release builds only with --dart-define=DURBUN=true. DurbunOptions.enabled overrides both.
  • Pure-Dart core for non-Flutter programs: package:durbun/durbun_core.dart.
0
likes
160
points
189
downloads
screenshot

Documentation

API reference

Publisher

verified publisherappnify.dev

Weekly Downloads

Network, log and crash inspector for Flutter apps: an in-app panel on the phone and live streaming to the Dürbün Mac app, with mocks and native capture.

Homepage
Repository (GitHub)
View/report issues
Contributing

Topics

#debugging #network #logging #inspector #http

License

MIT (license)

Dependencies

flutter

More

Packages that depend on durbun

Packages that implement durbun