couchbase 3.0.2 → 3.0.3

data/ext/couchbase/error_context/analytics.hxx

@@ -0,0 +1,46 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2020 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include <optional>
+#include <set>
+#include <string>
+
+#include <io/retry_reason.hxx>
+
+namespace couchbase::error_context
+{
+
+struct analytics {
+    std::error_code ec{};
+    std::string client_context_id{};
+    std::string statement{};
+    std::optional<std::string> parameters{};
+
+    std::string method{};
+    std::string path{};
+    std::uint32_t http_status{};
+    std::string http_body{};
+
+    std::optional<std::string> last_dispatched_to{};
+    std::optional<std::string> last_dispatched_from{};
+    int retry_attempts{ 0 };
+    std::set<io::retry_reason> retry_reasons{};
+};
+
+} // namespace couchbase::error_context

data/ext/couchbase/error_context/http.hxx

@@ -0,0 +1,44 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2020 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include <optional>
+#include <set>
+#include <string>
+
+#include <io/retry_reason.hxx>
+
+namespace couchbase::error_context
+{
+
+struct http {
+    std::error_code ec{};
+    std::string client_context_id{};
+
+    std::string method{};
+    std::string path{};
+    std::uint32_t http_status{};
+    std::string http_body{};
+
+    std::optional<std::string> last_dispatched_to{};
+    std::optional<std::string> last_dispatched_from{};
+    int retry_attempts{ 0 };
+    std::set<io::retry_reason> retry_reasons{};
+};
+
+} // namespace couchbase::error_context

data/ext/couchbase/error_context/key_value.hxx

@@ -0,0 +1,47 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2020 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include <optional>
+#include <set>
+#include <string>
+
+#include <document_id.hxx>
+#include <error_map.hxx>
+#include <io/retry_reason.hxx>
+#include <protocol/enhanced_error_info.hxx>
+#include <protocol/status.hxx>
+
+namespace couchbase::error_context
+{
+
+struct key_value {
+    document_id id{};
+    std::error_code ec{};
+    std::uint32_t opaque{};
+    std::optional<protocol::status> status_code{};
+    std::optional<error_map::error_info> error_map_info{};
+    std::optional<protocol::enhanced_error_info> enhanced_error_info{};
+
+    std::optional<std::string> last_dispatched_to{};
+    std::optional<std::string> last_dispatched_from{};
+    int retry_attempts{ 0 };
+    std::set<io::retry_reason> retry_reasons{};
+};
+
+} // namespace couchbase::error_context

data/ext/couchbase/error_context/query.hxx

@@ -0,0 +1,46 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2020 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include <optional>
+#include <set>
+#include <string>
+
+#include <io/retry_reason.hxx>
+
+namespace couchbase::error_context
+{
+
+struct query {
+    std::error_code ec{};
+    std::string client_context_id{};
+    std::string statement{};
+    std::optional<std::string> parameters{};
+
+    std::string method{};
+    std::string path{};
+    std::uint32_t http_status{};
+    std::string http_body{};
+
+    std::optional<std::string> last_dispatched_to{};
+    std::optional<std::string> last_dispatched_from{};
+    int retry_attempts{ 0 };
+    std::set<io::retry_reason> retry_reasons{};
+};
+
+} // namespace couchbase::error_context

data/ext/couchbase/error_context/search.hxx

@@ -0,0 +1,47 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2020 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include <optional>
+#include <set>
+#include <string>
+
+#include <io/retry_reason.hxx>
+
+namespace couchbase::error_context
+{
+
+struct search {
+    std::error_code ec{};
+    std::string client_context_id{};
+    std::string index_name{};
+    std::optional<std::string> query{};
+    std::optional<std::string> parameters{};
+
+    std::string method{};
+    std::string path{};
+    std::uint32_t http_status{};
+    std::string http_body{};
+
+    std::optional<std::string> last_dispatched_to{};
+    std::optional<std::string> last_dispatched_from{};
+    int retry_attempts{ 0 };
+    std::set<io::retry_reason> retry_reasons{};
+};
+
+} // namespace couchbase::error_context

data/ext/couchbase/error_context/view.hxx

@@ -0,0 +1,47 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2020 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include <optional>
+#include <set>
+#include <string>
+
+#include <io/retry_reason.hxx>
+
+namespace couchbase::error_context
+{
+
+struct view {
+    std::error_code ec{};
+    std::string client_context_id{};
+    std::string design_document_name{};
+    std::string view_name{};
+    std::vector<std::string> query_string{};
+
+    std::string method{};
+    std::string path{};
+    std::uint32_t http_status{};
+    std::string http_body{};
+
+    std::optional<std::string> last_dispatched_to{};
+    std::optional<std::string> last_dispatched_from{};
+    int retry_attempts{ 0 };
+    std::set<io::retry_reason> retry_reasons{};
+};
+
+} // namespace couchbase::error_context

data/ext/couchbase/io/dns_codec.hxx

@@ -19,8 +19,7 @@
 
 #include <cstring>
 
-#include <arpa/inet.h>
-
+#include <asio/ip/udp.hpp>
 #include <io/dns_message.hxx>
 
 namespace couchbase::io::dns

data/ext/couchbase/io/http_command.hxx

@@ -26,6 +26,7 @@ template<typename Request>
 struct http_command : public std::enable_shared_from_this<http_command<Request>> {
     using encoded_request_type = typename Request::encoded_request_type;
     using encoded_response_type = typename Request::encoded_response_type;
+    using error_context_type = typename Request::error_context_type;
     asio::steady_timer deadline;
     asio::steady_timer retry_backoff;
     Request request;
@@ -44,7 +45,10 @@ struct http_command : public std::enable_shared_from_this<http_command<Request>>
         encoded.type = request.type;
         auto encoding_ec = request.encode_to(encoded, session->http_context());
         if (encoding_ec) {
-            return handler(make_response(encoding_ec, request, {}));
+            error_context_type ctx{};
+            ctx.ec = encoding_ec;
+            ctx.client_context_id = request.client_context_id;
+            return handler(make_response(std::move(ctx), request, {}));
         }
         encoded.headers["client-context-id"] = request.client_context_id;
         auto log_prefix = session->log_prefix();
@@ -80,8 +84,17 @@ struct http_command : public std::enable_shared_from_this<http_command<Request>>
                                                       resp.status_code,
                                                       spdlog::to_hex(resp.body));
                                          try {
-                                             handler(make_response(ec, self->request, std::move(msg)));
-                                         } catch (priv::retry_http_request) {
+                                             error_context_type ctx{};
+                                             ctx.ec = ec;
+                                             ctx.client_context_id = self->request.client_context_id;
+                                             ctx.method = self->encoded.method;
+                                             ctx.path = self->encoded.path;
+                                             ctx.last_dispatched_from = session->local_address();
+                                             ctx.last_dispatched_to = session->remote_address();
+                                             ctx.http_status = msg.status_code;
+                                             ctx.http_body = msg.body;
+                                             handler(make_response(std::move(ctx), self->request, std::move(msg)));
+                                         } catch (priv::retry_http_request&) {
                                              self->send_to(session, std::forward<Handler>(handler));
                                          }
                                      });

data/ext/couchbase/io/http_context.hxx

@@ -30,7 +30,7 @@ struct http_context {
 
 namespace priv
 {
-class retry_http_request
+class retry_http_request : public std::exception
 {
 };
 } // namespace priv

data/ext/couchbase/io/http_session.hxx

@@ -17,8 +17,8 @@
 
 #pragma once
 
-#include <utility>
 #include <memory>
+#include <utility>
 
 #include <spdlog/spdlog.h>
 
@@ -30,9 +30,9 @@
 #include <errors.hxx>
 #include <version.hxx>
 
-#include <io/http_parser.hxx>
-#include <io/http_message.hxx>
 #include <io/http_context.hxx>
+#include <io/http_message.hxx>
+#include <io/http_parser.hxx>
 #include <platform/base64.h>
 #include <timeout_defaults.hxx>
 
@@ -103,11 +103,17 @@ class http_session : public std::enable_shared_from_this<http_session>
 
     std::string remote_address() const
     {
+        if (endpoint_.protocol() == asio::ip::tcp::v6()) {
+            return fmt::format("[{}]:{}", endpoint_address_, endpoint_.port());
+        }
         return fmt::format("{}:{}", endpoint_address_, endpoint_.port());
     }
 
     std::string local_address() const
     {
+        if (endpoint_.protocol() == asio::ip::tcp::v6()) {
+            return fmt::format("[{}]:{}", local_endpoint_address_, local_endpoint_.port());
+        }
         return fmt::format("{}:{}", local_endpoint_address_, local_endpoint_.port());
     }
 
@@ -178,12 +184,12 @@ class http_session : public std::enable_shared_from_this<http_session>
         state_ = diag::endpoint_state::disconnected;
     }
 
-    bool keep_alive()
+    bool keep_alive() const
     {
         return keep_alive_;
     }
 
-    bool is_stopped()
+    bool is_stopped() const
     {
         return stopped_;
     }
@@ -215,7 +221,7 @@ class http_session : public std::enable_shared_from_this<http_session>
         do_write();
     }
 
-    void write_and_subscribe(io::http_request& request, std::function<void(std::error_code, io::http_response&&)> handler)
+    void write_and_subscribe(io::http_request& request, std::function<void(std::error_code, io::http_response&&)>&& handler)
     {
         if (stopped_) {
             return;

data/ext/couchbase/io/http_session_manager.hxx

@@ -117,30 +117,31 @@ class http_session_manager : public std::enable_shared_from_this<http_session_ma
                     operations::http_noop_request request{};
                     request.type = type;
                     auto cmd = std::make_shared<operations::http_command<operations::http_noop_request>>(ctx_, request);
-                    cmd->send_to(session,
-                                 [start = std::chrono::steady_clock::now(),
-                                  self = shared_from_this(),
-                                  type,
-                                  session,
-                                  handler = collector->build_reporter()](operations::http_noop_response&& resp) mutable {
-                                     diag::ping_state state = diag::ping_state::ok;
-                                     std::optional<std::string> error{};
-                                     if (resp.ec) {
-                                         state = diag::ping_state::error;
-                                         error.emplace(fmt::format(
-                                           "code={}, message={}, http_code={}", resp.ec.value(), resp.ec.message(), resp.status_code));
-                                     }
-                                     handler(diag::endpoint_ping_info{
-                                       type,
-                                       session->id(),
-                                       std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now() - start),
-                                       session->remote_address(),
-                                       session->local_address(),
-                                       state,
-                                       {},
-                                       error });
-                                     self->check_in(type, session);
-                                 });
+                    cmd->send_to(
+                      session,
+                      [start = std::chrono::steady_clock::now(),
+                       self = shared_from_this(),
+                       type,
+                       session,
+                       handler = collector->build_reporter()](operations::http_noop_response&& resp) mutable {
+                          diag::ping_state state = diag::ping_state::ok;
+                          std::optional<std::string> error{};
+                          if (resp.ctx.ec) {
+                              state = diag::ping_state::error;
+                              error.emplace(fmt::format(
+                                "code={}, message={}, http_code={}", resp.ctx.ec.value(), resp.ctx.ec.message(), resp.ctx.http_status));
+                          }
+                          handler(diag::endpoint_ping_info{
+                            type,
+                            session->id(),
+                            std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now() - start),
+                            session->remote_address(),
+                            session->local_address(),
+                            state,
+                            {},
+                            error });
+                          self->check_in(type, session);
+                      });
                 }
             }
         }