{"id":13807156,"url":"https://github.com/confluentinc/bottledwater-pg","last_synced_at":"2025-05-14T00:30:57.899Z","repository":{"id":27191374,"uuid":"30661643","full_name":"confluentinc/bottledwater-pg","owner":"confluentinc","description":"Change data capture from PostgreSQL into Kafka","archived":false,"fork":false,"pushed_at":"2023-06-12T03:34:18.000Z","size":528,"stargazers_count":3,"open_issues_count":49,"forks_count":149,"subscribers_count":169,"default_branch":"master","last_synced_at":"2024-11-18T23:52:04.585Z","etag":null,"topics":[],"latest_commit_sha":null,"homepage":"http://blog.confluent.io/2015/04/23/bottled-water-real-time-integration-of-postgresql-and-kafka/","language":"C","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"apache-2.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/confluentinc.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":".github/CODEOWNERS","security":null,"support":null,"governance":null,"roadmap":null,"authors":null}},"created_at":"2015-02-11T18:02:02.000Z","updated_at":"2024-11-11T00:03:08.000Z","dependencies_parsed_at":"2024-01-22T19:33:45.015Z","dependency_job_id":"97c5a58a-7dbd-4cd5-9b2e-d10232bf42d6","html_url":"https://github.com/confluentinc/bottledwater-pg","commit_stats":null,"previous_names":[],"tags_count":1,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/confluentinc%2Fbottledwater-pg","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/confluentinc%2Fbottledwater-pg/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/confluentinc%2Fbottledwater-pg/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/confluentinc%2Fbottledwater-pg/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/confluentinc","download_url":"https://codeload.github.com/confluentinc/bottledwater-pg/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":254046232,"owners_count":22005558,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":[],"created_at":"2024-08-04T01:01:21.743Z","updated_at":"2025-05-14T00:30:52.883Z","avatar_url":"https://github.com/confluentinc.png","language":"C","funding_links":[],"categories":["Data Ingestion","Database Tools"],"sub_categories":[],"readme":"NOTE: Bottled Water is unmaintained\n===================================\n\n**Please note that Bottled Water is no longer being actively developed.**\n\nBottled Water pioneered change data capture from PostgreSQL into Kafka using the logical decoding\nAPI, but now other projects have adopted the technique and are continuing to develop it. Please see\nthe following resources for supported solutions for CDC from PostgreSQL into Kafka:\n\n* The [Kafka Connector list](https://www.confluent.io/product/connectors/) provides an overview\n  of projects that integrate databases with the\n  [Kafka Connect framework](http://docs.confluent.io/current/connect/index.html).\n* [Debezium](http://debezium.io/) integrates PostgreSQL with Kafka in a way that is similar to\n  Bottled Water.\n\nThe remaining README is kept here for historical interest.\n\n\nBottled Water for PostgreSQL\n============================\n\nHow do you export water from your country? Well, you first go to your reservoir, pump out all the\nwater, and fill it into bottles. You then go to the streams of clear mountain water flowing into\nthe reservoir, and tap into them, filling the fresh water into bottles as it arrives. Then you\nship those bottles all around the world.\n\nHow do you export data from your database? Well, you first take a consistent snapshot of your\nentire database, and encode it in a language-independent format. You then look at the stream of\ntransactions writing to your database, and parse the transaction log, encoding the\ninserts/updates/deletes into the same language-independent format as they happen. Then you take\nthat data and ship it to your other systems: build search indexes, update caches, load it into\na data warehouse, calculate analytics, monitor it for fraud, and so on.\n\n* [Blog post explaining the background](http://blog.confluent.io/2015/04/23/bottled-water-real-time-integration-of-postgresql-and-kafka/)\n* [Watch a short demo!](http://showterm.io/fde6260d684ee3a6ee692)\n\n\nHow it works\n------------\n\nBottled Water uses the [logical decoding](http://www.postgresql.org/docs/9.5/static/logicaldecoding.html)\nfeature (introduced in PostgreSQL 9.4) to extract a consistent snapshot and a continuous stream\nof change events from a database. The data is extracted at a row level, and encoded using\n[Avro](http://avro.apache.org/). A client program connects to your database, extracts this data,\nand relays it to [Kafka](http://kafka.apache.org/) (you could also integrate it with other systems\nif you wish, but Kafka is pretty awesome).\n\nKey features of Bottled Water are:\n\n* Works with any PostgreSQL database (version 9.4 or later). There are no restrictions on your\n  database schema.\n* No schema changes are required, no triggers or additional tables. (However, you do need to be\n  able to install a PostgreSQL extension on the database server. More on this below.)\n* Negligible impact on database performance.\n* Transactionally consistent output. That means: writes appear only when they are committed to the\n  database (writes by aborted transactions are discarded), writes appear in the same order as they\n  were committed (no race conditions).\n* Fault-tolerant: does not lose data, even if processes crash, machines die, the network is\n  interrupted, etc.\n\n\nQuickstart\n----------\n\nThere are several possible ways of installing and trying Bottled Water:\n\n* [Running in Docker](#running-in-docker) is the fastest way of getting started, but currently\n  only recommended for development environments.\n* [Building from source](#building-from-source) is the most flexible, but also a bit fiddly.\n* There are also [Ubuntu packages](https://launchpad.net/~stub/+archive/ubuntu/bottledwater),\n  built by Stuart Bishop (Canonical).\n\n\nRunning in Docker\n-----------------\n\nThe easiest way to try Bottled Water is to use the [Docker](https://www.docker.com/) images we have\nprepared. You need at least 2GB of memory to run this demo, so if you're running inside a virtual\nmachine (such as [Boot2docker](http://boot2docker.io/) on a Mac), please check that it is big\nenough.\n\nFirst, install:\n\n* [Docker](https://docs.docker.com/installation/), which is used to run the\n  individual services/containers, and\n* [docker-compose](https://docs.docker.com/compose/install/), which is used to\n  orchestrate the interaction between services.\n\nAfter the prerequisite applications are installed, you need to build the Docker containers for Bottled Water and Postgres:\n\n    $ make docker-compose\n\nOnce the build process finishes, set up some required environment variables,\nthen start up Postgres, Kafka and the [Confluent schema\nregistry](http://confluent.io/docs/current/schema-registry/docs/intro.html) by\nrunning `docker-compose` as follows:\n\n    $ export KAFKA_ADVERTISED_HOST_NAME=$(docker run --rm debian:jessie ip route | awk '/^default via / { print $3 }') \\\n             KAFKA_LOG_CLEANUP_POLICY=compact \\\n             KAFKA_AUTO_CREATE_TOPICS_ENABLE=true\n    $ docker-compose up -d kafka schema-registry postgres\n\nThe `postgres-bw` image extends the\n[official Postgres docker image](https://registry.hub.docker.com/_/postgres/) and adds\nBottled Water support. However, before Bottled Water can be used, it first needs to be\nenabled. To do this, start a `psql` shell for the Postgres database:\n\n    $ docker-compose run --rm psql\n\nWhen the prompt appears, enable the `bottledwater` extension, and create a database with\nsome test data, for example:\n\n    create extension bottledwater;\n    create table test (id serial primary key, value text);\n    insert into test (value) values('hello world!');\n\nYou can keep the psql terminal open, and run the following in a new terminal.\n\nThe next step is to start the Bottled Water client, which relays data from Postgres to Kafka.\nYou start it like this:\n\n    $ docker-compose up -d bottledwater-avro\n\nYou can run `docker-compose logs bottledwater-avro` to see what it's doing. Now Bottled\nWater has taken the snapshot, and continues to watch Postgres for any data changes. You can\nsee the data that has been extracted from Postgres by consuming from Kafka (the topic name\n`test` must match up with the name of the table you created earlier):\n\n    $ docker-compose run --rm kafka-avro-console-consumer \\\n        --from-beginning --property print.key=true --topic test\n\nThis should print out the contents of the `test` table in JSON format (key/value separated\nby tab). Now go back to the `psql` terminal, and change some data — insert, update or delete\nsome rows in the `test` table. You should see the changes swiftly appear in the Kafka\nconsumer terminal.\n\nWhen you're done testing, you can destroy the cluster and it's associated data volumes with:\n\n    $ docker-compose stop\n    $ docker-compose rm -vf\n\nBuilding from source\n--------------------\n\nTo compile Bottled Water is just a matter of:\n\n    make \u0026\u0026 make install\n\nFor that to work, you need the following dependencies installed:\n\n* [PostgreSQL 9.5](http://www.postgresql.org/) development libraries (PGXS and libpq).\n  (Homebrew: `brew install postgresql`;\n  Ubuntu: `sudo apt-get install postgresql-server-dev-9.5 libpq-dev`)\n* [libsnappy](https://code.google.com/p/snappy/), a dependency of Avro.\n  (Homebrew: `brew install snappy`; Ubuntu: `sudo apt-get install libsnappy-dev`)\n* [avro-c](http://avro.apache.org/) (1.8.0 or later), the C implementation of Avro.\n  (Homebrew: `brew install avro-c`; others: build from source)\n* [Jansson](http://www.digip.org/jansson/), a JSON parser.\n  (Homebrew: `brew install jansson`; Ubuntu: `sudo apt-get install libjansson-dev`)\n* [libcurl](http://curl.haxx.se/libcurl/), a HTTP client.\n  (Homebrew: `brew install curl`; Ubuntu: `sudo apt-get install libcurl4-openssl-dev`)\n* [librdkafka](https://github.com/edenhill/librdkafka) (0.9.1 or later), a Kafka client.\n  (Ubuntu universe: `sudo apt-get install librdkafka-dev`, but see [known gotchas](#known-gotchas-with-older-dependencies); others: build from source)\n\nYou can see the Dockerfile for\n[building the quickstart images](https://github.com/ept/bottledwater-pg/blob/master/build/Dockerfile.build)\nas an example of building Bottled Water and its dependencies on Debian.\n\nIf you get errors about *Package libsnappy was not found in the pkg-config search path*,\nand you have Snappy installed, you may need to create `/usr/local/lib/pkgconfig/libsnappy.pc`\nwith contents something like the following (be sure to check which version of _libsnappy_\nis installed in your system):\n\n    Name: libsnappy\n    Description: Snappy is a compression library\n    Version: 1.1.2\n    URL: https://google.github.io/snappy/\n    Libs: -L/usr/local/lib -lsnappy\n    Cflags: -I/usr/local/include\n\n\nConfiguration\n-------------\n\nThe `make install` command above installs an extension into the Postgres installation on\nyour machine, which does all the work of encoding change data into Avro. There's then a\nseparate client program which connects to Postgres, fetches the data, and pushes it to Kafka.\n\nTo configure Bottled Water, you need to set the following in `postgresql.conf`: (If you're\nusing Homebrew, you can probably find it in `/usr/local/var/postgres`. On Linux, it's\nprobably in `/etc/postgres`.)\n\n    wal_level = logical\n    max_wal_senders = 8\n    wal_keep_segments = 4\n    max_replication_slots = 4\n\nYou'll also need to give yourself the replication privileges for the database. You can do\nthis by adding the following to `pg_hba.conf` (in the same directory, replacing `\u003cuser\u003e`\nwith your login username):\n\n    local   replication     \u003cuser\u003e                 trust\n    host    replication     \u003cuser\u003e  127.0.0.1/32   trust\n    host    replication     \u003cuser\u003e  ::1/128        trust\n\nRestart Postgres for the changes to take effect. Next, enable the Postgres extension that\n`make install` installed previously. Start `psql -h localhost` and run:\n\n    create extension bottledwater;\n\nThat should be all the setup on the Postgres side. Next, make sure you're running Kafka\nand the [Confluent schema registry](http://confluent.io/docs/current/schema-registry/docs/index.html),\nfor example by following the [quickstart](http://confluent.io/docs/current/quickstart.html).\n\nAssuming that everything is running on the default ports on localhost, you can start\nBottled Water as follows:\n\n    ./kafka/bottledwater --postgres=postgres://localhost\n\nThe first time this runs, it will create a replication slot called `bottledwater`,\ntake a consistent snapshot of your database, and send it to Kafka. (You can change the\nname of the replication slot with the `--slot` [command line\nflag](#command-line-options).) When the snapshot is complete, it switches to consuming\nthe replication stream.\n\nIf the slot already exists, the tool assumes that no snapshot is needed, and simply\nresumes the replication stream where it last left off.\n\nIn some scenarios, if you only care about streaming ongoing changes (and not\nreplicating the existing database contents into Kafka), you may want to skip the\nsnapshot - e.g. to avoid the performance overhead of taking the snapshot, or because\nyou are repointing Bottled Water at a newly promoted replica.  In that case, you can\npass `--skip-snapshot` at the [command line](#command-line-options).  (This option is\nignored if the replication slot already exists.)\n\nWhen you no longer want to run Bottled Water, you have to drop its replication slot\n(otherwise you'll eventually run out of disk space, as the open replication slot\nprevents the WAL from getting garbage-collected). You can do this by opening `psql`\nagain and running:\n\n    select pg_drop_replication_slot('bottledwater');\n\n\n### Error handling\n\nIf Bottled Water encounters an error - such as failure to communicate with Kafka or\nthe Schema Registry - its default behaviour is for the client to exit, halting the\nflow of data into Kafka.  This may seem like an odd default, but since Postgres will\nretain and replay the logical replication stream until Bottled Water acknowledges it,\nit ensures that:\n\n * it will never miss an update (every update made in Postgres will eventually be\n   written to Kafka) - _provided_ that whatever caused the error is resolved\n   externally (e.g.  restoring connectivity to Kafka) and the Bottled Water client is\n   then restarted;\n\n * it will never write corrupted data to Kafka: e.g. if unable to obtain a schema id\n   from the Schema Registry for the current update, rather than writing to Kafka\n   without a schema id (which would leave consumers unable to parse the update), it\n   will wait until the problem is resolved.\n\nHowever, in some scenarios, exiting on the first error may not be desirable:\n\n * if there is an error publishing for one table (e.g. if Kafka is configured not to\n   autocreate topics and the corresponding topic has not been explicitly created), you\n   may not want to halt updates for all other tables.\n\n * if the reason for the error cannot be resolved quickly (e.g. Kafka misconfiguration\n   or prolonged outage), Bottled Water may threaten the stability of the Postgres\n   server.  This is because Postgres will store WAL on disk for all updates made since\n   Bottled Water last acknowledged (i.e. successfully published) an update.  If\n   Postgres has a high write throughput, Bottled Water being unavailable may cause the\n   disk on the Postgres server to fill up, likely causing Postgres to crash.\n\nTo support these scenarios, Bottled Water supports an alternative error handling\npolicy where it will simply log that the error occurred and drop the update it was\nattempting to process, acknowledging the update so that Postgres can stop retaining\nWAL.  This policy can be enabled via the `--on-error` [command-line\nswitch](#command-line-options).  N.B. that in this mode Bottled Water can no longer\nguarantee to never miss an update.\n\n\nConsuming data\n--------------\n\nBottled Water creates one Kafka topic per database table, with the same name as the\ntable. The messages in the topic use the table's primary key (or replica identity\nindex, if set) as key, and the entire table row as value. With inserts and updates,\nthe message value is the new contents of the row. With deletes, the message value\nis null, which allows Kafka's [log compaction](http://kafka.apache.org/documentation.html#compaction)\nto garbage-collect deleted values.\n\nIf a table doesn't have a primary key or replica identity index, Bottled Water will\ncomplain and refuse to start. You can override this with the `--allow-unkeyed`\n[option](#command-line-options).  Any inserts and updates to tables without primary\nkey or replica identity will be sent to Kafka as messages without a key. Deletes to\nsuch tables are not sent to Kafka.\n\nMessages are written to Kafka by default in a binary Avro encoding, which is\nefficient, but not human-readable. To view the contents of a Kafka topic, you can use\nthe Avro console consumer:\n\n    ./bin/kafka-avro-console-consumer --topic test --zookeeper localhost:2181 \\\n        --property print.key=true\n\n\n### Output formats\n\nBottled Water currently supports writing messages to Kafka in one of two output\nformats: Avro, or JSON.  The output format is configured via the `--output-format`\n[command-line switch](#command-line-options).\n\nAvro is recommended for large scale use, since it uses a much more efficient binary\nencoding for messages, defines rules for [schema\nevolution](http://docs.confluent.io/1.0/avro.html), and is able to faithfully\nrepresent a wide range of column types.  Avro output requires an instance of the\n[Confluent Schema\nRegistry](http://docs.confluent.io/1.0/schema-registry/docs/intro.html) to be running,\nand consumers will need to query the schema registry in order to decode messages.\n\nJSON is ideal for evaluation and prototyping, or integration with languages\nwithout good Avro library support.  JSON is human readable, and widely supported among\nprogramming languages.  JSON output does not require a schema registry.\n\n\n### Topic names\n\nFor each table being streamed, Bottled Water publishes messages to a corresponding\nKafka topic.  The naming convention for topics is\n*\\[topic_prefix\\].\\[postgres_schema_name\\].table_name*:\n\n * *table_name* is the name of the table in Postgres.\n * *postgres_schema_name* is the name of the Postgres\n   [schema](https://www.postgresql.org/docs/current/static/sql-createschema.html) the\n   table belongs to; this is omitted if the schema is \"public\" (the default schema\n   under the default Postgres configuration).  N.B. this requires the avro-c library\n   to be [at least version 0.8.0](#avro-c--080-schema-omitted-from-topic-name).\n * *topic_prefix* is omitted by default, but may be configured via the\n   `--topic-prefix` [command-line option](#command-line-options).  A prefix is useful:\n       * to prevent name collisions with other topics, if the Kafka broker is also\n         being used for other purposes besides Bottled Water.\n       * if you want to stream several databases into the same broker, using a\n         separate Bottled Water instance with a different prefix for each database.\n       * to make it easier for a Kafka consumer to consume updates from all Postgres\n         tables, by using a topic regex that matches the prefix.\n\nFor example:\n\n * with no prefix configured, a table named \"users\" in the public (default) schema\n   would be streamed to a topic named \"users\".\n * with `--topic-prefix=bottledwater`, a table named \"transactions\" in the\n   \"point-of-sale\" schema would be streamed to a topic named\n   \"bottledwater.point-of-sale.transactions\".\n\n(Support for [namespaces in\nKafka](https://cwiki.apache.org/confluence/display/KAFKA/KIP-37+-+Add+Namespaces+to+Kafka)\nhas been proposed that would replace this sort of ad-hoc prefixing, but it's still\nunder discussion.)\n\n\nKnown gotchas with older dependencies\n-------------------------------------\n\nIt is recommended to compile Bottled Water against the versions of librdkafka and\navro-c specified [above](#building-from-source).  However, Bottled Water may work with\nolder versions, with degraded functionality.\n\nAt time of writing, the librdkafka-dev packages in the official Ubuntu repositories\n(for all releases up to 15.10) contain a release prior to 0.8.6.  This means if you\nare building on Ubuntu, building librdkafka from source is recommended, until an\nupdated librdkafka package is available.\n\n### librdkafka \u0026lt; 0.8.6: empty messages sent for deletes\n\nAs noted [above](#consuming-data), Bottled Water sends a null message to represent a\nrow deletion.  librdkafka only added [support for null\nmessages](https://github.com/edenhill/librdkafka/pull/200) in [release 0.8.6](https://github.com/edenhill/librdkafka/releases/tag/0.8.6).  If Bottled Water\nis compiled against a version of librdkafka prior to 0.8.6, deletes will instead be\nrepresented by *empty* messages, i.e. a message whose payload is an empty byte\nsequence.  This means that Kafka will not garbage-collect deleted values on log\ncompaction, and also may confuse consumers that expect all non-null message payloads\nto begin with a header.\n\n### librdkafka \u0026lt; 0.9.0: messages partitioned randomly\n\nlibrdkafka 0.9.0+ provides a \"consistent partitioner\", which assigns messages to\npartitions based on the hash of the key.  Bottled Water takes advantage of this\nto ensure that all inserts, updates and deletes for a given key get sent to the\nsame partition.\n\nIf Bottled Water is compiled against a version of librdkafka prior to 0.9.0,\nmessages will instead be assigned randomly to partitions.  If the topic\ncorresponding to a given table has more than one partition, this will lead to\nincorrect log compaction behaviour (e.g. if the initial insert for row 42 goes\nto partition 0, then a subsequent delete for row 42 goes to partition 1, then\nlog compaction will be unable to garbage-collect the insert).  It will also\nbreak any consumer relying on seeing all updates relating to a given key (e.g.\nfor a stream-table join).\n\n### avro-c \u0026lt; 0.8.0: schema omitted from topic name\n\nBottled Water encodes the Postgres schema to which tables belong in the Avro schema\nnamespace.  Support for accessing the schema namespace was added to the Avro C library\nin version 0.8.0, so prior releases do not have access to this information.\n\nIf Bottled Water is compiled against a version of avro-c prior to 0.8.0, the schema\nwill be omitted from the [Kafka topic name](#topic-names).  This means that tables\nwith the same names in different schemas will have changes streamed to the same topic.\n\n\nCommand-line options\n--------------------\n\nThis serves as a reference for the various command-line options accepted by the\nBottled Water client, annotated with links to the relevant areas of documentation.\nIf this disagrees with the output of `bottledwater --help`, then `--help` is correct\n(and please file a pull request to update this reference!).\n\n\n * `-d`, `--postgres=postgres://user:pass@host:port/dbname` **(required)**:\n   Connection string or URI of the PostgreSQL server.\n\n * `-s`, `--slot=slotname` *(default: bottledwater)*:\n   Name of [replication slot](#configuration).  The slot is automatically created on\n   first use.\n\n * `-b`, `--broker=host1[:port1],host2[:port2]...` *(default: localhost:9092)*:\n   Comma-separated list of Kafka broker hosts/ports.\n\n * `-r`, `--schema-registry=http://hostname:port` *(default: http://localhost:8081)*:\n   URL of the service where Avro schemas are registered.  (Used only for\n   `--output-format=avro`.  Omit when `--output-format=json`.)\n\n * `-f`, `--output-format=[avro|json]` *(default: avro)*:\n   How to encode the messages for writing to Kafka.  See discussion of [output\n   formats](#output-formats).\n\n * `-u`, `--allow-unkeyed`:\n   Allow export of tables that don't have a primary key.  This is [disallowed by\n   default](#consuming-data), because updates and deletes need a primary key to\n   identify their row.\n\n * `-p`, `--topic-prefix=prefix`:\n   String to prepend to all [topic names](#topic-names).  e.g. with\n   `--topic-prefix=postgres`, updates from table \"users\" will be written to topic\n   \"postgres.users\".\n\n * `-e`, `--on-error=[log|exit]` *(default: exit)*:\n   What to do in case of a transient error, such as failure to publish to Kafka.  See\n   discussion of [error handling](#error-handling).\n\n * `-x`, `--skip-snapshot`:\n   Skip taking a [consistent snapshot](#configuration) of the existing database\n   contents and just start streaming any new updates.  (Ignored if the replication\n   slot already exists.)\n\n * `-C`, `--kafka-config property=value`:\n   Set global configuration property for Kafka producer (see [librdkafka\n   docs](https://github.com/edenhill/librdkafka/blob/master/CONFIGURATION.md)).\n\n * `-T`, `--topic-config property=value`:\n   Set topic configuration property for Kafka producer (see [librdkafka\n   docs](https://github.com/edenhill/librdkafka/blob/master/CONFIGURATION.md)).\n\n * `--config-help`:\n   Print the list of Kafka configuration properties.\n\n * `-h`, `--help`: Print this help text.\n\n\nDeveloping\n----------\n\nIf you want to work on the Bottled Water codebase, the [Docker setup](#running-in-docker) is\na good place to start.\n\nBottled Water ships with a [test suite](spec) that [verifies basic\nfunctionality](spec/functional/message_spec.rb), [documents supported Postgres\ntypes](spec/functional/type_specs.rb) and [tests message publishing\nsemantics](spec/functional/partitioning_spec.rb).  The test suite also relies on Docker and\nDocker Compose.  To run it:\n\n 1. Install Docker and Docker Compose (see [Docker setup](#running-in-docker))\n 2. Install Ruby 2.2.4 (see [ruby-lang.org](https://www.ruby-lang.org/en/downloads/))\n    (required to run the tests)\n 3. Install Bundler: `gem install bundler`\n 4. Build the Docker images: `make docker-compose`\n 5. Run the tests: `make test`\n\nIf submitting a pull request, particularly one that adds new functionality, it is highly\nencouraged to include tests that exercise the changed code!\n\n\nStatus\n------\n\nBottled Water has been tested on a variety of use cases and Postgres schemas, and is\nbelieved to be fairly stable.  In particular, because of its design, it is unlikely to\ncorrupt the data in Postgres. However, it has not yet been run on large production\ndatabases, or for long periods of time, so proceed with caution if you intend to use\nit in production.  See [this discussion about production\nreadiness](https://github.com/confluentinc/bottledwater-pg/issues/96), and [Github\nissues](https://github.com/confluentinc/bottledwater-pg/issues) for a list of known\nissues.\n\nBug reports and pull requests welcome.\n\nNote that Bottled Water has nothing to do with\n[Sparkling Water](https://github.com/h2oai/sparkling-water), a machine learning\nengine for Spark.\n\n\nLicense\n-------\n\nCopyright 2015 Confluent, Inc.\n\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use this\nsoftware except in compliance with the License in the enclosed file called\n[`LICENSE`](LICENSE).\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n\nSee [`CONTRIBUTORS.md`](CONTRIBUTORS.md) for a list of contributors.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fconfluentinc%2Fbottledwater-pg","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fconfluentinc%2Fbottledwater-pg","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fconfluentinc%2Fbottledwater-pg/lists"}