{"ok": true, "database": "tils", "table": "til", "rows": [{"path": "cloudrun_tailing-cloud-run-request-logs.md", "topic": "cloudrun", "title": "Tailing Google Cloud Run request logs and importing them into SQLite", "url": "https://github.com/simonw/til/blob/main/cloudrun/tailing-cloud-run-request-logs.md", "body": "The `gcloud` CLI tool has [the alpha ability to tail log files](https://cloud.google.com/logging/docs/reference/tools/gcloud-logging#live-tailing) - but it's a bit of a pain to setup.\n\nYou have to install two extras for it. First, this:\n\n    gcloud alpha logging tail\n\nThat installs the functionality, but as the documentation will tell you:\n\n> To use `gcloud alpha logging tail`, you need to have Python 3 and the `grpcio` Python package installed.\n\nAssuming you have Python 3, the problem you have to solve is *which Python* is the `gcloud` tool using to run. After digging around in the source code using `cat $(which gcloud)` I spotted the following:\n\n    CLOUDSDK_PYTHON=$(order_python python3 python2 python2.7 python)\n\nSo it looks like (on macOS at least) it prefers to use the `python3` binary if it can find it.\n\nSo this works to install `grpcio` somewhere it can see it:\n\n    python3 -m pip install grpcio\n\nHaving done that, you can start running commands. `gcloud logging logs list` shows a list of logs:\n\n```\n~ % gcloud logging logs list\nNAME\nprojects/datasette-222320/logs/cloudaudit.googleapis.com%2Factivity\nprojects/datasette-222320/logs/cloudaudit.googleapis.com%2Fdata_access\nprojects/datasette-222320/logs/cloudaudit.googleapis.com%2Fsystem_event\nprojects/datasette-222320/logs/cloudbuild\nprojects/datasette-222320/logs/clouderrorreporting.googleapis.com%2Finsights\nprojects/datasette-222320/logs/cloudtrace.googleapis.com%2FTraceLatencyShiftDetected\nprojects/datasette-222320/logs/run.googleapis.com%2Frequests\nprojects/datasette-222320/logs/run.googleapis.com%2Fstderr\nprojects/datasette-222320/logs/run.googleapis.com%2Fstdout\nprojects/datasette-222320/logs/run.googleapis.com%2Fvarlog%2Fsystem\n```\nThen you can use `gcloud alpha logging tail projects/datasette-222320/logs/run.googleapis.com%2Frequests` to start logging. Only you also need a `CLOUDSDK_PYTHON_SITEPACKAGES=1` environment variable so that `gcloud` knows to look for the `grpcio` dependency.\n\n    CLOUDSDK_PYTHON_SITEPACKAGES=1 \\\n      gcloud alpha logging tail projects/datasette-222320/logs/run.googleapis.com%2Frequests\n\nThe default format is verbose YAML. A log entry looks like this:\n\n```yaml\nhttpRequest:\n  latency: 0.123684963s\n  remoteIp: 66.249.69.240\n  requestMethod: GET\n  requestSize: '510'\n  requestUrl: https://www.niche-museums.com/browse/museums.json?_facet_size=max&country=United+States&_facet=osm_city&_facet=updated&_facet=osm_suburb&_facet=osm_footway&osm_city=Santa+Cruz\n  responseSize: '6403'\n  serverIp: 142.250.125.121\n  status: 200\n  userAgent: Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)\ninsertId: 611171fe000a38a469d59595\nlabels:\n  instanceId: 00bf4bf02dab164592dbbb9220b56c3ce64cb0f1c1f37812d1d61e851a931e9964ba539c2ede42886773c82662cc28aa858749d2697f537ff7a61e7b\n  service: niche-museums\nlogName: projects/datasette-222320/logs/run.googleapis.com%2Frequests\nreceiveTimestamp: '2021-08-09T18:20:46.935658405Z'\nresource:\n  labels:\n    configuration_name: niche-museums\n    location: us-central1\n    project_id: datasette-222320\n    revision_name: niche-museums-00039-sur\n    service_name: niche-museums\n  type: cloud_run_revision\nseverity: INFO\ntimestamp: '2021-08-09T18:20:46.669860Z'\ntrace: projects/datasette-222320/traces/306a0d6e7e055ba66172003a74c926c2\n```\n\nI decided to import into a SQLite database so I could use [Datasette](https://datasette.io/) to analyze the log files (hooray for facets).\n\nAdding `--format json` switches the output to JSON - but it's a pretty-printed array of JSON objects, something like this:\n\n```json\n[\n  {\n    \"httpRequest\": {\n      \"latency\": \"0.112114537s\",\n      \"remoteIp\": \"40.77.167.88\",\n      \"requestMethod\": \"GET\",\n      \"requestSize\": \"534\",\n      \"requestUrl\": \"https://datasette.io/content/repos?forks=0&_facet=homepage&_facet=size&_facet=open_issues&open_issues=3&size=564&_sort=readme_html\",\n      \"responseSize\": \"72757\",\n      \"serverIp\": \"216.239.38.21\",\n      \"status\": 200,\n      \"userAgent\": \"Mozilla/5.0 (compatible; bingbot/2.0; +http://www.bing.com/bingbot.htm)\"\n    },\n    \"insertId\": \"6111722f000b5b4c4d4071e2\",\n    \"labels\": {\n      \"instanceId\": \"00bf4bf02d1d7fe4402c3aff8a34688d9a910e6ee6d2545ceebc1edefb99461481e6d9f9ae8de4e907e3d18b98ea9c7f57b2abb527c8857d9163ed193db766c349a1ee\",\n      \"service\": \"datasette-io\"\n    },\n    \"logName\": \"projects/datasette-222320/logs/run.googleapis.com%2Frequests\",\n    \"receiveTimestamp\": \"2021-08-09T18:21:36.061693305Z\",\n    \"resource\": {\n      \"labels\": {\n        \"configuration_name\": \"datasette-io\",\n        \"location\": \"us-central1\",\n        \"project_id\": \"datasette-222320\",\n        \"revision_name\": \"datasette-io-00416-coy\",\n        \"service_name\": \"datasette-io\"\n      },\n      \"type\": \"cloud_run_revision\"\n    },\n    \"severity\": \"INFO\",\n    \"timestamp\": \"2021-08-09T18:21:35.744268Z\",\n    \"trace\": \"projects/datasette-222320/traces/016d640caf845fbf8709486bc8dff9c7\"\n  }\n]\n```\n\nI want to stream the logs into `sqlite-utils` using [newline-delimited JSON](https://sqlite-utils.datasette.io/en/stable/cli.html#inserting-newline-delimited-json) since that can insert while the data is still being tailed.\n\nI ended up using two new `jq` recipes:\n\n    cat example.json | jq -cn --stream 'fromstream(1|truncate_stream(inputs))'\n\nThis turns an `[{\"array\": \"of objects\"}, {\"like\": \"this one\"}]` into a stream of newline-delimited objects. I [found the recipe here](https://github.com/stedolan/jq/issues/1984#issuecomment-568918146) - I don't understand it.\n\nAs you can see above, the objects are nested. I want them as flat objects so that `sqlite-utils insert` will create a separate column for each nested value. I used [this recipe](https://til.simonwillison.net/jq/flatten-nested-json-objects-jq) for that.\n\nThe end result was this:\n\n```\nCLOUDSDK_PYTHON_SITEPACKAGES=1 gcloud alpha logging tail \\\n  projects/datasette-222320/logs/run.googleapis.com%2Frequests \\\n  --format json \\\n| jq -cn --stream 'fromstream(1|truncate_stream(inputs))' \\\n| jq -c '[leaf_paths as $path | {\n  \"key\": $path | join(\"_\"), \"value\": getpath($path)\n}] | from_entries' \\\n| sqlite-utils insert /tmp/logs.db logs - --nl --alter --batch-size 1\n```\nThat last line inserts the data into the `/tmp/logs.db` database file. `--nl` means \"expect newline-delimited JSON\", `--alter` means \"add new columns if they are missing\", `--batch-size 1` means \"commit after every record\" (so I can see them in Datasette while they are streaming in).\n\n**UPDATE:** [sqlite-utils 3.15](https://sqlite-utils.datasette.io/en/stable/changelog.html#v3-15) added a `--flatten` option which you can use instead of that second `jq` recipe, so this should work instead:\n\n```\nCLOUDSDK_PYTHON_SITEPACKAGES=1 gcloud alpha logging tail \\\n  projects/datasette-222320/logs/run.googleapis.com%2Frequests \\\n  --format json \\\n| jq -cn --stream 'fromstream(1|truncate_stream(inputs))' \\\n| sqlite-utils insert /tmp/logs.db logs - --nl --alter --batch-size 1 --flatten\n```\n\nThe resulting schema looks like this (via `sqlite-utils schema /tmp/logs.db`):\n```sql\nCREATE TABLE [logs] (\n   [httpRequest_latency] TEXT,\n   [httpRequest_remoteIp] TEXT,\n   [httpRequest_requestMethod] TEXT,\n   [httpRequest_requestSize] TEXT,\n   [httpRequest_requestUrl] TEXT,\n   [httpRequest_responseSize] TEXT,\n   [httpRequest_serverIp] TEXT,\n   [httpRequest_status] INTEGER,\n   [httpRequest_userAgent] TEXT,\n   [insertId] TEXT,\n   [labels_instanceId] TEXT,\n   [labels_service] TEXT,\n   [logName] TEXT,\n   [receiveTimestamp] TEXT,\n   [resource_labels_configuration_name] TEXT,\n   [resource_labels_location] TEXT,\n   [resource_labels_project_id] TEXT,\n   [resource_labels_revision_name] TEXT,\n   [resource_labels_service_name] TEXT,\n   [resource_type] TEXT,\n   [severity] TEXT,\n   [timestamp] TEXT,\n   [trace] TEXT,\n   [httpRequest_referer] TEXT\n);\n```\n\nThen I ran `datasette /tmp/logs.db` to start exploring the logs. Faceting by `resource_labels_service_name` was particularly useful.\n\n<img width=\"1340\" alt=\"Screenshot of logs in Datasette\" src=\"https://user-images.githubusercontent.com/9599/128755995-fab7e478-82a5-4d80-a959-f89f7dd39209.png\">\n\nThe `httpRequest_latency` column contains text data that looks like `0.012572683s` - thankfully if you cast it to a `float` the trailing `s` will be ignored. Here's an example query showing the services with the highest average latency:\n\n```sql\nselect\n  resource_labels_service_name,\n  avg(cast(httpRequest_latency as float)) as avg_latency,\n  count(*)\nfrom\n  logs\ngroup by\n  resource_labels_service_name\norder by\n  avg_latency desc\n```\n\n## Using the Logs explorer\n\nAlternatively, you can use the Google Cloud logs explorer! It has pretty decent faceted search built in.\n\nHere's a query showing results from that log file:\n```\nresource.type=\"cloud_run_revision\"\nlog_name=\"projects/datasette-222320/logs/run.googleapis.com%2Frequests\"\n```\nRun that at https://console.cloud.google.com/logs/query - or here's a link I can use to execute that directly (for the last 7 days): https://console.cloud.google.com/logs/query;query=resource.type%3D%22cloud_run_revision%22%0Alog_name%3D%22projects%2Fdatasette-222320%2Flogs%2Frun.googleapis.com%252Frequests%22;timeRange=P7D;?project=datasette-222320", "html": "<p>The <code>gcloud</code> CLI tool has <a href=\"https://cloud.google.com/logging/docs/reference/tools/gcloud-logging#live-tailing\" rel=\"nofollow\">the alpha ability to tail log files</a> - but it's a bit of a pain to setup.</p>\n<p>You have to install two extras for it. First, this:</p>\n<pre><code>gcloud alpha logging tail\n</code></pre>\n<p>That installs the functionality, but as the documentation will tell you:</p>\n<blockquote>\n<p>To use <code>gcloud alpha logging tail</code>, you need to have Python 3 and the <code>grpcio</code> Python package installed.</p>\n</blockquote>\n<p>Assuming you have Python 3, the problem you have to solve is <em>which Python</em> is the <code>gcloud</code> tool using to run. After digging around in the source code using <code>cat $(which gcloud)</code> I spotted the following:</p>\n<pre><code>CLOUDSDK_PYTHON=$(order_python python3 python2 python2.7 python)\n</code></pre>\n<p>So it looks like (on macOS at least) it prefers to use the <code>python3</code> binary if it can find it.</p>\n<p>So this works to install <code>grpcio</code> somewhere it can see it:</p>\n<pre><code>python3 -m pip install grpcio\n</code></pre>\n<p>Having done that, you can start running commands. <code>gcloud logging logs list</code> shows a list of logs:</p>\n<pre><code>~ % gcloud logging logs list\nNAME\nprojects/datasette-222320/logs/cloudaudit.googleapis.com%2Factivity\nprojects/datasette-222320/logs/cloudaudit.googleapis.com%2Fdata_access\nprojects/datasette-222320/logs/cloudaudit.googleapis.com%2Fsystem_event\nprojects/datasette-222320/logs/cloudbuild\nprojects/datasette-222320/logs/clouderrorreporting.googleapis.com%2Finsights\nprojects/datasette-222320/logs/cloudtrace.googleapis.com%2FTraceLatencyShiftDetected\nprojects/datasette-222320/logs/run.googleapis.com%2Frequests\nprojects/datasette-222320/logs/run.googleapis.com%2Fstderr\nprojects/datasette-222320/logs/run.googleapis.com%2Fstdout\nprojects/datasette-222320/logs/run.googleapis.com%2Fvarlog%2Fsystem\n</code></pre>\n<p>Then you can use <code>gcloud alpha logging tail projects/datasette-222320/logs/run.googleapis.com%2Frequests</code> to start logging. Only you also need a <code>CLOUDSDK_PYTHON_SITEPACKAGES=1</code> environment variable so that <code>gcloud</code> knows to look for the <code>grpcio</code> dependency.</p>\n<pre><code>CLOUDSDK_PYTHON_SITEPACKAGES=1 \\\n  gcloud alpha logging tail projects/datasette-222320/logs/run.googleapis.com%2Frequests\n</code></pre>\n<p>The default format is verbose YAML. A log entry looks like this:</p>\n<div class=\"highlight highlight-source-yaml\"><pre><span class=\"pl-ent\">httpRequest</span>:\n  <span class=\"pl-ent\">latency</span>: <span class=\"pl-s\">0.123684963s</span>\n  <span class=\"pl-ent\">remoteIp</span>: <span class=\"pl-s\">66.249.69.240</span>\n  <span class=\"pl-ent\">requestMethod</span>: <span class=\"pl-s\">GET</span>\n  <span class=\"pl-ent\">requestSize</span>: <span class=\"pl-s\"><span class=\"pl-pds\">'</span>510<span class=\"pl-pds\">'</span></span>\n  <span class=\"pl-ent\">requestUrl</span>: <span class=\"pl-s\">https://www.niche-museums.com/browse/museums.json?_facet_size=max&amp;country=United+States&amp;_facet=osm_city&amp;_facet=updated&amp;_facet=osm_suburb&amp;_facet=osm_footway&amp;osm_city=Santa+Cruz</span>\n  <span class=\"pl-ent\">responseSize</span>: <span class=\"pl-s\"><span class=\"pl-pds\">'</span>6403<span class=\"pl-pds\">'</span></span>\n  <span class=\"pl-ent\">serverIp</span>: <span class=\"pl-s\">142.250.125.121</span>\n  <span class=\"pl-ent\">status</span>: <span class=\"pl-c1\">200</span>\n  <span class=\"pl-ent\">userAgent</span>: <span class=\"pl-s\">Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)</span>\n<span class=\"pl-ent\">insertId</span>: <span class=\"pl-s\">611171fe000a38a469d59595</span>\n<span class=\"pl-ent\">labels</span>:\n  <span class=\"pl-ent\">instanceId</span>: <span class=\"pl-s\">00bf4bf02dab164592dbbb9220b56c3ce64cb0f1c1f37812d1d61e851a931e9964ba539c2ede42886773c82662cc28aa858749d2697f537ff7a61e7b</span>\n  <span class=\"pl-ent\">service</span>: <span class=\"pl-s\">niche-museums</span>\n<span class=\"pl-ent\">logName</span>: <span class=\"pl-s\">projects/datasette-222320/logs/run.googleapis.com%2Frequests</span>\n<span class=\"pl-ent\">receiveTimestamp</span>: <span class=\"pl-s\"><span class=\"pl-pds\">'</span>2021-08-09T18:20:46.935658405Z<span class=\"pl-pds\">'</span></span>\n<span class=\"pl-ent\">resource</span>:\n  <span class=\"pl-ent\">labels</span>:\n    <span class=\"pl-ent\">configuration_name</span>: <span class=\"pl-s\">niche-museums</span>\n    <span class=\"pl-ent\">location</span>: <span class=\"pl-s\">us-central1</span>\n    <span class=\"pl-ent\">project_id</span>: <span class=\"pl-s\">datasette-222320</span>\n    <span class=\"pl-ent\">revision_name</span>: <span class=\"pl-s\">niche-museums-00039-sur</span>\n    <span class=\"pl-ent\">service_name</span>: <span class=\"pl-s\">niche-museums</span>\n  <span class=\"pl-ent\">type</span>: <span class=\"pl-s\">cloud_run_revision</span>\n<span class=\"pl-ent\">severity</span>: <span class=\"pl-s\">INFO</span>\n<span class=\"pl-ent\">timestamp</span>: <span class=\"pl-s\"><span class=\"pl-pds\">'</span>2021-08-09T18:20:46.669860Z<span class=\"pl-pds\">'</span></span>\n<span class=\"pl-ent\">trace</span>: <span class=\"pl-s\">projects/datasette-222320/traces/306a0d6e7e055ba66172003a74c926c2</span></pre></div>\n<p>I decided to import into a SQLite database so I could use <a href=\"https://datasette.io/\" rel=\"nofollow\">Datasette</a> to analyze the log files (hooray for facets).</p>\n<p>Adding <code>--format json</code> switches the output to JSON - but it's a pretty-printed array of JSON objects, something like this:</p>\n<div class=\"highlight highlight-source-json\"><pre>[\n  {\n    <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>httpRequest<span class=\"pl-pds\">\"</span></span>: {\n      <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>latency<span class=\"pl-pds\">\"</span></span>: <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>0.112114537s<span class=\"pl-pds\">\"</span></span>,\n      <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>remoteIp<span class=\"pl-pds\">\"</span></span>: <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>40.77.167.88<span class=\"pl-pds\">\"</span></span>,\n      <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>requestMethod<span class=\"pl-pds\">\"</span></span>: <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>GET<span class=\"pl-pds\">\"</span></span>,\n      <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>requestSize<span class=\"pl-pds\">\"</span></span>: <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>534<span class=\"pl-pds\">\"</span></span>,\n      <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>requestUrl<span class=\"pl-pds\">\"</span></span>: <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>https://datasette.io/content/repos?forks=0&amp;_facet=homepage&amp;_facet=size&amp;_facet=open_issues&amp;open_issues=3&amp;size=564&amp;_sort=readme_html<span class=\"pl-pds\">\"</span></span>,\n      <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>responseSize<span class=\"pl-pds\">\"</span></span>: <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>72757<span class=\"pl-pds\">\"</span></span>,\n      <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>serverIp<span class=\"pl-pds\">\"</span></span>: <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>216.239.38.21<span class=\"pl-pds\">\"</span></span>,\n      <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>status<span class=\"pl-pds\">\"</span></span>: <span class=\"pl-c1\">200</span>,\n      <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>userAgent<span class=\"pl-pds\">\"</span></span>: <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>Mozilla/5.0 (compatible; bingbot/2.0; +http://www.bing.com/bingbot.htm)<span class=\"pl-pds\">\"</span></span>\n    },\n    <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>insertId<span class=\"pl-pds\">\"</span></span>: <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>6111722f000b5b4c4d4071e2<span class=\"pl-pds\">\"</span></span>,\n    <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>labels<span class=\"pl-pds\">\"</span></span>: {\n      <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>instanceId<span class=\"pl-pds\">\"</span></span>: <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>00bf4bf02d1d7fe4402c3aff8a34688d9a910e6ee6d2545ceebc1edefb99461481e6d9f9ae8de4e907e3d18b98ea9c7f57b2abb527c8857d9163ed193db766c349a1ee<span class=\"pl-pds\">\"</span></span>,\n      <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>service<span class=\"pl-pds\">\"</span></span>: <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>datasette-io<span class=\"pl-pds\">\"</span></span>\n    },\n    <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>logName<span class=\"pl-pds\">\"</span></span>: <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>projects/datasette-222320/logs/run.googleapis.com%2Frequests<span class=\"pl-pds\">\"</span></span>,\n    <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>receiveTimestamp<span class=\"pl-pds\">\"</span></span>: <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>2021-08-09T18:21:36.061693305Z<span class=\"pl-pds\">\"</span></span>,\n    <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>resource<span class=\"pl-pds\">\"</span></span>: {\n      <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>labels<span class=\"pl-pds\">\"</span></span>: {\n        <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>configuration_name<span class=\"pl-pds\">\"</span></span>: <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>datasette-io<span class=\"pl-pds\">\"</span></span>,\n        <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>location<span class=\"pl-pds\">\"</span></span>: <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>us-central1<span class=\"pl-pds\">\"</span></span>,\n        <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>project_id<span class=\"pl-pds\">\"</span></span>: <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>datasette-222320<span class=\"pl-pds\">\"</span></span>,\n        <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>revision_name<span class=\"pl-pds\">\"</span></span>: <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>datasette-io-00416-coy<span class=\"pl-pds\">\"</span></span>,\n        <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>service_name<span class=\"pl-pds\">\"</span></span>: <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>datasette-io<span class=\"pl-pds\">\"</span></span>\n      },\n      <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>type<span class=\"pl-pds\">\"</span></span>: <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>cloud_run_revision<span class=\"pl-pds\">\"</span></span>\n    },\n    <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>severity<span class=\"pl-pds\">\"</span></span>: <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>INFO<span class=\"pl-pds\">\"</span></span>,\n    <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>timestamp<span class=\"pl-pds\">\"</span></span>: <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>2021-08-09T18:21:35.744268Z<span class=\"pl-pds\">\"</span></span>,\n    <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>trace<span class=\"pl-pds\">\"</span></span>: <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>projects/datasette-222320/traces/016d640caf845fbf8709486bc8dff9c7<span class=\"pl-pds\">\"</span></span>\n  }\n]</pre></div>\n<p>I want to stream the logs into <code>sqlite-utils</code> using <a href=\"https://sqlite-utils.datasette.io/en/stable/cli.html#inserting-newline-delimited-json\" rel=\"nofollow\">newline-delimited JSON</a> since that can insert while the data is still being tailed.</p>\n<p>I ended up using two new <code>jq</code> recipes:</p>\n<pre><code>cat example.json | jq -cn --stream 'fromstream(1|truncate_stream(inputs))'\n</code></pre>\n<p>This turns an <code>[{\"array\": \"of objects\"}, {\"like\": \"this one\"}]</code> into a stream of newline-delimited objects. I <a href=\"https://github.com/stedolan/jq/issues/1984#issuecomment-568918146\">found the recipe here</a> - I don't understand it.</p>\n<p>As you can see above, the objects are nested. I want them as flat objects so that <code>sqlite-utils insert</code> will create a separate column for each nested value. I used <a href=\"https://til.simonwillison.net/jq/flatten-nested-json-objects-jq\" rel=\"nofollow\">this recipe</a> for that.</p>\n<p>The end result was this:</p>\n<pre><code>CLOUDSDK_PYTHON_SITEPACKAGES=1 gcloud alpha logging tail \\\n  projects/datasette-222320/logs/run.googleapis.com%2Frequests \\\n  --format json \\\n| jq -cn --stream 'fromstream(1|truncate_stream(inputs))' \\\n| jq -c '[leaf_paths as $path | {\n  \"key\": $path | join(\"_\"), \"value\": getpath($path)\n}] | from_entries' \\\n| sqlite-utils insert /tmp/logs.db logs - --nl --alter --batch-size 1\n</code></pre>\n<p>That last line inserts the data into the <code>/tmp/logs.db</code> database file. <code>--nl</code> means \"expect newline-delimited JSON\", <code>--alter</code> means \"add new columns if they are missing\", <code>--batch-size 1</code> means \"commit after every record\" (so I can see them in Datasette while they are streaming in).</p>\n<p><strong>UPDATE:</strong> <a href=\"https://sqlite-utils.datasette.io/en/stable/changelog.html#v3-15\" rel=\"nofollow\">sqlite-utils 3.15</a> added a <code>--flatten</code> option which you can use instead of that second <code>jq</code> recipe, so this should work instead:</p>\n<pre><code>CLOUDSDK_PYTHON_SITEPACKAGES=1 gcloud alpha logging tail \\\n  projects/datasette-222320/logs/run.googleapis.com%2Frequests \\\n  --format json \\\n| jq -cn --stream 'fromstream(1|truncate_stream(inputs))' \\\n| sqlite-utils insert /tmp/logs.db logs - --nl --alter --batch-size 1 --flatten\n</code></pre>\n<p>The resulting schema looks like this (via <code>sqlite-utils schema /tmp/logs.db</code>):</p>\n<div class=\"highlight highlight-source-sql\"><pre>CREATE TABLE [logs] (\n   [httpRequest_latency] <span class=\"pl-k\">TEXT</span>,\n   [httpRequest_remoteIp] <span class=\"pl-k\">TEXT</span>,\n   [httpRequest_requestMethod] <span class=\"pl-k\">TEXT</span>,\n   [httpRequest_requestSize] <span class=\"pl-k\">TEXT</span>,\n   [httpRequest_requestUrl] <span class=\"pl-k\">TEXT</span>,\n   [httpRequest_responseSize] <span class=\"pl-k\">TEXT</span>,\n   [httpRequest_serverIp] <span class=\"pl-k\">TEXT</span>,\n   [httpRequest_status] <span class=\"pl-k\">INTEGER</span>,\n   [httpRequest_userAgent] <span class=\"pl-k\">TEXT</span>,\n   [insertId] <span class=\"pl-k\">TEXT</span>,\n   [labels_instanceId] <span class=\"pl-k\">TEXT</span>,\n   [labels_service] <span class=\"pl-k\">TEXT</span>,\n   [logName] <span class=\"pl-k\">TEXT</span>,\n   [receiveTimestamp] <span class=\"pl-k\">TEXT</span>,\n   [resource_labels_configuration_name] <span class=\"pl-k\">TEXT</span>,\n   [resource_labels_location] <span class=\"pl-k\">TEXT</span>,\n   [resource_labels_project_id] <span class=\"pl-k\">TEXT</span>,\n   [resource_labels_revision_name] <span class=\"pl-k\">TEXT</span>,\n   [resource_labels_service_name] <span class=\"pl-k\">TEXT</span>,\n   [resource_type] <span class=\"pl-k\">TEXT</span>,\n   [severity] <span class=\"pl-k\">TEXT</span>,\n   [<span class=\"pl-k\">timestamp</span>] <span class=\"pl-k\">TEXT</span>,\n   [trace] <span class=\"pl-k\">TEXT</span>,\n   [httpRequest_referer] <span class=\"pl-k\">TEXT</span>\n);</pre></div>\n<p>Then I ran <code>datasette /tmp/logs.db</code> to start exploring the logs. Faceting by <code>resource_labels_service_name</code> was particularly useful.</p>\n<p><a href=\"https://user-images.githubusercontent.com/9599/128755995-fab7e478-82a5-4d80-a959-f89f7dd39209.png\" target=\"_blank\" rel=\"nofollow\"><img width=\"1340\" alt=\"Screenshot of logs in Datasette\" src=\"https://user-images.githubusercontent.com/9599/128755995-fab7e478-82a5-4d80-a959-f89f7dd39209.png\" style=\"max-width:100%;\"></a></p>\n<p>The <code>httpRequest_latency</code> column contains text data that looks like <code>0.012572683s</code> - thankfully if you cast it to a <code>float</code> the trailing <code>s</code> will be ignored. Here's an example query showing the services with the highest average latency:</p>\n<div class=\"highlight highlight-source-sql\"><pre><span class=\"pl-k\">select</span>\n  resource_labels_service_name,\n  <span class=\"pl-c1\">avg</span>(cast(httpRequest_latency <span class=\"pl-k\">as</span> float)) <span class=\"pl-k\">as</span> avg_latency,\n  <span class=\"pl-c1\">count</span>(<span class=\"pl-k\">*</span>)\n<span class=\"pl-k\">from</span>\n  logs\n<span class=\"pl-k\">group by</span>\n  resource_labels_service_name\n<span class=\"pl-k\">order by</span>\n  avg_latency <span class=\"pl-k\">desc</span></pre></div>\n<h2>\n<a id=\"user-content-using-the-logs-explorer\" class=\"anchor\" href=\"#using-the-logs-explorer\" aria-hidden=\"true\"><span aria-hidden=\"true\" class=\"octicon octicon-link\"></span></a>Using the Logs explorer</h2>\n<p>Alternatively, you can use the Google Cloud logs explorer! It has pretty decent faceted search built in.</p>\n<p>Here's a query showing results from that log file:</p>\n<pre><code>resource.type=\"cloud_run_revision\"\nlog_name=\"projects/datasette-222320/logs/run.googleapis.com%2Frequests\"\n</code></pre>\n<p>Run that at <a href=\"https://console.cloud.google.com/logs/query\" rel=\"nofollow\">https://console.cloud.google.com/logs/query</a> - or here's a link I can use to execute that directly (for the last 7 days): <a href=\"https://console.cloud.google.com/logs/query;query=resource.type%3D%22cloud_run_revision%22%0Alog_name%3D%22projects%2Fdatasette-222320%2Flogs%2Frun.googleapis.com%252Frequests%22;timeRange=P7D;?project=datasette-222320\" rel=\"nofollow\">https://console.cloud.google.com/logs/query;query=resource.type%3D%22cloud_run_revision%22%0Alog_name%3D%22projects%2Fdatasette-222320%2Flogs%2Frun.googleapis.com%252Frequests%22;timeRange=P7D;?project=datasette-222320</a></p>\n", "shot": {"$base64": true, "encoded": "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"}, "created": "2021-08-09T11:32:01-07:00", "created_utc": "2021-08-09T18:32:01+00:00", "updated": "2021-08-13T22:07:23-07:00", "updated_utc": "2021-08-14T05:07:23+00:00", "shot_hash": "eba49d224d98a67308c137bcc3f0e777", "slug": "tailing-cloud-run-request-logs"}], "primary_keys": ["path"], "primary_key_values": ["cloudrun_tailing-cloud-run-request-logs.md"], "query_ms": 2.124130001902813, "truncated": false}