libcouchbase 1.3.0 → 1.3.2

data/ext/libcouchbase/src/tracing/threshold_logging_tracer.cc

@@ -40,6 +40,8 @@ static void tlt_destructor(lcbtrace_TRACER *wrapper)
     }
     if (wrapper->cookie) {
         ThresholdLoggingTracer *tracer = reinterpret_cast< ThresholdLoggingTracer * >(wrapper->cookie);
+        tracer->do_flush_orphans();
+        tracer->do_flush_threshold();
         delete tracer;
         wrapper->cookie = NULL;
     }
@@ -53,11 +55,15 @@ static void tlt_report(lcbtrace_TRACER *wrapper, lcbtrace_SPAN *span)
     }
 
     ThresholdLoggingTracer *tracer = reinterpret_cast< ThresholdLoggingTracer * >(wrapper->cookie);
-    if (span->tags[LCBTRACE_TAG_SERVICE] == LCBTRACE_TAG_SERVICE_KV) {
-        if (lcbtrace_span_is_orphaned(span)) {
-            tracer->add_orphan(span);
-        } else {
-            tracer->check_threshold(span);
+    char *value = NULL;
+    size_t nvalue;
+    if (lcbtrace_span_get_tag_str(span, LCBTRACE_TAG_SERVICE, &value, &nvalue) == LCB_SUCCESS) {
+        if (strncmp(value, LCBTRACE_TAG_SERVICE_KV, nvalue) == 0) {
+            if (lcbtrace_span_is_orphaned(span)) {
+                tracer->add_orphan(span);
+            } else {
+                tracer->check_threshold(span);
+            }
         }
     }
 }
@@ -77,17 +83,39 @@ lcbtrace_TRACER *ThresholdLoggingTracer::wrap()
     return m_wrapper;
 }
 
-ReportedSpan ThresholdLoggingTracer::convert(lcbtrace_SPAN *span)
+QueueEntry ThresholdLoggingTracer::convert(lcbtrace_SPAN *span)
 {
-    ReportedSpan orphan;
+    QueueEntry orphan;
     orphan.duration = span->duration();
     Json::Value entry;
-    entry["operation_name"] = span->m_opname;
-    entry["operation_id"] = span->tags[LCBTRACE_TAG_OPERATION_ID];
-    entry["last_local_id"] = span->tags[LCBTRACE_TAG_LOCAL_ID];
-    entry["last_local_address"] = span->tags[LCBTRACE_TAG_LOCAL_ADDRESS];
-    entry["last_remote_address"] = span->tags[LCBTRACE_TAG_PEER_ADDRESS];
-    entry["server_us"] = span->tags[LCBTRACE_TAG_PEER_LATENCY];
+    char *value;
+    size_t nvalue;
+
+    if (lcbtrace_span_get_tag_str(
+                span, LCBTRACE_TAG_OPERATION_ID, &value, &nvalue) ==
+        LCB_SUCCESS) {
+        entry["last_operation_id"] = std::string(span->m_opname) + ":" +
+                                     std::string(value, value + nvalue);
+    }
+    if (lcbtrace_span_get_tag_str(
+                span, LCBTRACE_TAG_LOCAL_ID, &value, &nvalue) == LCB_SUCCESS) {
+        entry["last_local_id"] = std::string(value, value + nvalue);
+    }
+    if (lcbtrace_span_get_tag_str(
+                span, LCBTRACE_TAG_LOCAL_ADDRESS, &value, &nvalue) ==
+        LCB_SUCCESS) {
+        entry["last_local_address"] = std::string(value, value + nvalue);
+    }
+    if (lcbtrace_span_get_tag_str(
+                span, LCBTRACE_TAG_PEER_ADDRESS, &value, &nvalue) ==
+        LCB_SUCCESS) {
+        entry["last_remote_address"] = std::string(value, value + nvalue);
+    }
+    uint64_t num;
+    if (lcbtrace_span_get_tag_uint64(span, LCBTRACE_TAG_PEER_LATENCY, &num) ==
+        LCB_SUCCESS) {
+        entry["server_us"] = (Json::UInt64)num;
+    }
     entry["total_us"] = (Json::UInt64)orphan.duration;
     orphan.payload = Json::FastWriter().write(entry);
     return orphan;
@@ -105,26 +133,46 @@ void ThresholdLoggingTracer::check_threshold(lcbtrace_SPAN *span)
     }
 }
 
-void ThresholdLoggingTracer::flush_queue(FixedQueue< ReportedSpan > &queue, const char *message)
+void ThresholdLoggingTracer::flush_queue(FixedSpanQueue &queue, const char *message, bool warn = false)
 {
-    std::vector< ReportedSpan > &slice = queue.get_sorted();
     Json::Value entries;
     entries["service"] = "kv";
-    entries["count"] = (Json::UInt)slice.size();
+    entries["count"] = (Json::UInt)queue.size();
     Json::Value top;
-    for (size_t ii = 0; ii < slice.size(); ii++) {
+    while (!queue.empty())
+    {
         Json::Value entry;
-        if (Json::Reader().parse(slice[ii].payload, entry)) {
+        if (Json::Reader().parse(queue.top().payload, entry)) {
             top.append(entry);
         }
+        queue.pop();
     }
     entries["top"] = top;
     std::string doc = Json::FastWriter().write(entries);
     if (doc.size() > 0 && doc[doc.size() - 1] == '\n') {
         doc[doc.size() - 1] = '\0';
     }
-    lcb_log(LOGARGS(this, WARN), "%s: %s", message, doc.c_str());
-    queue.clear();
+    if (warn) {
+        lcb_log(LOGARGS(this, WARN), "%s: %s", message, doc.c_str());
+    } else {
+        lcb_log(LOGARGS(this, INFO), "%s: %s", message, doc.c_str());
+    }
+}
+
+void ThresholdLoggingTracer::do_flush_orphans()
+{
+    if (m_orphans.empty()) {
+        return;
+    }
+    flush_queue(m_orphans, "Orphan responses observed", true);
+}
+
+void ThresholdLoggingTracer::do_flush_threshold()
+{
+    if (m_threshold.empty()) {
+        return;
+    }
+    flush_queue(m_threshold, "Operations over threshold");
 }
 
 void ThresholdLoggingTracer::flush_orphans()
@@ -135,10 +183,7 @@ void ThresholdLoggingTracer::flush_orphans()
     } else {
         m_oflush.rearm(tv);
     }
-    if (m_orphans.empty()) {
-        return;
-    }
-    flush_queue(m_orphans, "Orphan responses observed");
+    do_flush_orphans();
 }
 
 void ThresholdLoggingTracer::flush_threshold()
@@ -149,10 +194,7 @@ void ThresholdLoggingTracer::flush_threshold()
     } else {
         m_tflush.rearm(tv);
     }
-    if (m_threshold.empty()) {
-        return;
-    }
-    flush_queue(m_threshold, "Operations over threshold");
+    do_flush_threshold();
 }
 
 ThresholdLoggingTracer::ThresholdLoggingTracer(lcb_t instance)

data/ext/libcouchbase/src/tracing/tracing-internal.h

@@ -35,6 +35,7 @@ class Span
 {
   public:
     Span(lcbtrace_TRACER *tracer, const char *opname, uint64_t start, lcbtrace_REF_TYPE ref, lcbtrace_SPAN *other);
+    ~Span();
 
     void finish(uint64_t finish);
     uint64_t duration()
@@ -42,7 +43,11 @@ class Span
         return m_finish - m_start;
     }
 
-    template < typename T > void add_tag(const char *name, T value);
+    void add_tag(const char *name, int copy, const char *value);
+    void add_tag(const char *name, int copy, const char *value, size_t value_len);
+    void add_tag(const char *name, int copy, uint64_t value);
+    void add_tag(const char *name, int copy, double value);
+    void add_tag(const char *name, int copy, bool value);
 
     lcbtrace_TRACER *m_tracer;
     std::string m_opname;
@@ -50,8 +55,8 @@ class Span
     uint64_t m_start;
     uint64_t m_finish;
     bool m_orphaned;
-    Json::Value tags;
     Span *m_parent;
+    sllist_root m_tags;
 };
 
 struct ReportedSpan {
@@ -64,61 +69,37 @@ struct ReportedSpan {
     }
 };
 
-template < typename T > class FixedQueue
+template < typename T > class FixedQueue: private std::priority_queue<T>
 {
   public:
     explicit FixedQueue(size_t capacity) : m_capacity(capacity) {}
 
-    void push(T item)
-    {
-        if (m_items.size() < m_capacity) {
-            m_items.push_back(item);
-            std::push_heap(m_items.begin(), m_items.end());
-        } else {
-            std::sort_heap(m_items.begin(), m_items.end());
-            if (m_items.front() < item) {
-                m_items[0] = item;
-            }
-            std::make_heap(m_items.begin(), m_items.end());
+    void push(const T& item) {
+        std::priority_queue<T>::push(item);
+        if (this->size() > m_capacity) {
+            this->c.pop_back();
         }
     }
-
-    size_t size()
-    {
-        return m_items.size();
-    }
-
-    bool empty()
-    {
-        return m_items.empty();
-    }
-
-    void clear()
-    {
-        m_items.clear();
-    }
-
-    std::vector< T > &get_sorted()
-    {
-        std::sort_heap(m_items.begin(), m_items.end());
-        return m_items;
-    }
-
+    using std::priority_queue<T>::empty;
+    using std::priority_queue<T>::top;
+    using std::priority_queue<T>::pop;
+    using std::priority_queue<T>::size;
   private:
     size_t m_capacity;
-    std::vector< T > m_items;
 };
 
+typedef ReportedSpan QueueEntry;
+typedef FixedQueue<QueueEntry> FixedSpanQueue;
 class ThresholdLoggingTracer
 {
     lcbtrace_TRACER *m_wrapper;
     lcb_settings *m_settings;
 
-    FixedQueue< ReportedSpan > m_orphans;
-    FixedQueue< ReportedSpan > m_threshold;
+    FixedSpanQueue m_orphans;
+    FixedSpanQueue m_threshold;
 
-    void flush_queue(FixedQueue< ReportedSpan > &queue, const char *message);
-    ReportedSpan convert(lcbtrace_SPAN *span);
+    void flush_queue(FixedSpanQueue &queue, const char *message, bool warn);
+    QueueEntry convert(lcbtrace_SPAN *span);
 
   public:
     ThresholdLoggingTracer(lcb_t instance);
@@ -129,6 +110,8 @@ class ThresholdLoggingTracer
 
     void flush_orphans();
     void flush_threshold();
+    void do_flush_orphans();
+    void do_flush_threshold();
 
     lcb::io::Timer< ThresholdLoggingTracer, &ThresholdLoggingTracer::flush_orphans > m_oflush;
     lcb::io::Timer< ThresholdLoggingTracer, &ThresholdLoggingTracer::flush_threshold > m_tflush;
@@ -164,14 +147,16 @@ void lcbtrace_span_set_orphaned(lcbtrace_SPAN *span, int val);
         if (span) {                                                                                                    \
             lcbtrace_span_add_tag_uint64(span, LCBTRACE_TAG_PEER_LATENCY, (response)->duration());                     \
             lcb::Server *server = static_cast< lcb::Server * >(pipeline);                                              \
-            const lcb_host_t &remote = server->get_host();                                                             \
-            std::string hh;                                                                                            \
-            if (remote.ipv6) {                                                                                         \
-                hh.append("[").append(remote.host).append("]:").append(remote.port);                                   \
-            } else {                                                                                                   \
-                hh.append(remote.host).append(":").append(remote.port);                                                \
+            const lcb_host_t *remote = server->curhost;                                                                \
+            if (remote) {                                                                                              \
+                std::string hh;                                                                                        \
+                if (remote->ipv6) {                                                                                    \
+                    hh.append("[").append(remote->host).append("]:").append(remote->port);                             \
+                } else {                                                                                               \
+                    hh.append(remote->host).append(":").append(remote->port);                                          \
+                }                                                                                                      \
+                lcbtrace_span_add_tag_str(span, LCBTRACE_TAG_PEER_ADDRESS, hh.c_str());                                \
             }                                                                                                          \
-            lcbtrace_span_add_tag_str(span, LCBTRACE_TAG_PEER_ADDRESS, hh.c_str());                                    \
             lcbio_CTX *ctx = server->connctx;                                                                          \
             if (ctx) {                                                                                                 \
                 char local_id[34] = {};                                                                                \

data/ext/libcouchbase/src/vbucket/vbucket.c

@@ -385,7 +385,7 @@ build_server_strings(lcbvb_CONFIG *cfg, lcbvb_SERVER *server)
  * @return
  */
 static int
-build_server_3x(lcbvb_CONFIG *cfg, lcbvb_SERVER *server, cJSON *js)
+build_server_3x(lcbvb_CONFIG *cfg, lcbvb_SERVER *server, cJSON *js, char **network)
 {
     cJSON *jsvcs;
     char *htmp;
@@ -414,6 +414,37 @@ build_server_3x(lcbvb_CONFIG *cfg, lcbvb_SERVER *server, cJSON *js)
         goto GT_ERR;
     }
 
+    if (network && *network && strcmp(*network, "default") != 0) {
+        cJSON *jaltaddr = cJSON_GetObjectItem(js, "alternateAddresses");
+        if (jaltaddr && jaltaddr->type == cJSON_Object) {
+            cJSON *jnetwork = cJSON_GetObjectItem(jaltaddr, *network);
+            if (jnetwork && get_jstr(jnetwork, "hostname", &htmp)) {
+                cJSON *jports;
+                server->alt_hostname = strdup(htmp);
+                jports = cJSON_GetObjectItem(jnetwork, "ports");
+                if (jports && jports->type == cJSON_Object) {
+                    extract_services(cfg, jports, &server->alt_svc, 0);
+                    extract_services(cfg, jports, &server->alt_svc_ssl, 1);
+                }
+
+#define COPY_SERVICE(src, dst)                                          \
+                if ((dst)->data == 0) (dst)->data = (src)->data;        \
+                if ((dst)->mgmt == 0) (dst)->mgmt = (src)->mgmt;        \
+                if ((dst)->views == 0) (dst)->views = (src)->views;     \
+                if ((dst)->n1ql == 0) (dst)->n1ql = (src)->n1ql;        \
+                if ((dst)->fts == 0) (dst)->fts = (src)->fts;           \
+                if ((dst)->ixadmin == 0) (dst)->ixadmin = (src)->ixadmin; \
+                if ((dst)->ixquery == 0) (dst)->ixquery = (src)->ixquery; \
+                if ((dst)->cbas == 0) (dst)->cbas = (src)->cbas;
+
+                COPY_SERVICE(&server->svc, &server->alt_svc);
+                COPY_SERVICE(&server->svc_ssl, &server->alt_svc_ssl);
+
+#undef COPY_SERVICE
+            }
+        }
+    }
+
     return 1;
 
     GT_ERR:
@@ -427,7 +458,7 @@ build_server_3x(lcbvb_CONFIG *cfg, lcbvb_SERVER *server, cJSON *js)
  * @return nonzero on success, 0 on failure.
  */
 static int
-build_server_2x(lcbvb_CONFIG *cfg, lcbvb_SERVER *server, cJSON *js)
+build_server_2x(lcbvb_CONFIG *cfg, lcbvb_SERVER *server, cJSON *js, char **network)
 {
     char *tmp = NULL, *colon;
     int itmp;
@@ -508,12 +539,49 @@ build_server_2x(lcbvb_CONFIG *cfg, lcbvb_SERVER *server, cJSON *js)
     return 0;
 }
 
+static void
+guess_network(cJSON *jnodes, int nsrv, const char *source, char **network)
+{
+    int ii;
+    for (ii = 0; ii < nsrv; ii++) {
+        cJSON *jsrv = cJSON_GetArrayItem(jnodes, ii);
+        {
+            cJSON *jhostname = cJSON_GetObjectItem(jsrv, "hostname");
+            if (jhostname && jhostname->type == cJSON_String) {
+                if (strcmp(jhostname->valuestring, source) == 0) {
+                    *network = strdup("default");
+                    return;
+                }
+            }
+        }
+        {
+            cJSON *jaltaddr = cJSON_GetObjectItem(jsrv, "alternateAddresses");
+            if (jaltaddr && jaltaddr->type == cJSON_Object) {
+                cJSON *cur;
+                for (cur = jaltaddr->child; cur != NULL; cur = cur->next) {
+                    if (cur->type == cJSON_Object) {
+                        cJSON *jhostname = cJSON_GetObjectItem(cur, "hostname");
+                        if (jhostname && jhostname->type == cJSON_String) {
+                            if (strcmp(jhostname->valuestring, source) == 0) {
+                                *network = strdup(cur->string);
+                                return;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    *network = strdup("default");
+}
+
 int
-lcbvb_load_json(lcbvb_CONFIG *cfg, const char *data)
+lcbvb_load_json_ex(lcbvb_CONFIG *cfg, const char *data, const char *source, char **network)
 {
-    cJSON *cj = NULL, *jnodes = NULL;
+    cJSON *cj = NULL, *jnodes_ext = NULL, *jnodes = NULL;
     char *tmp = NULL;
-    unsigned ii;
+    unsigned ii, jnodes_size = 0;
+    int jnodes_defined = 0;
 
     if ((cj = cJSON_Parse(data)) == NULL) {
         SET_ERRSTR(cfg, "Couldn't parse JSON");
@@ -531,9 +599,16 @@ lcbvb_load_json(lcbvb_CONFIG *cfg, const char *data)
         goto GT_ERROR;
     }
 
-    if (get_jarray(cj, "nodesExt", &jnodes)) {
+    get_jarray(cj, "nodes", &jnodes);
+    if (jnodes) {
+        jnodes_defined = 1;
+        jnodes_size = cJSON_GetArraySize(jnodes);
+    }
+    if (get_jarray(cj, "nodesExt", &jnodes_ext)) {
         cfg->is3x = 1;
-    } else if (!get_jarray(cj, "nodes", &jnodes)) {
+        cfg->nsrv = cJSON_GetArraySize(jnodes_ext);
+        jnodes = jnodes_ext;
+    } else if (jnodes == NULL) {
         SET_ERRSTR(cfg, "expected 'nodesExt' or 'nodes' array");
         goto GT_ERROR;
     }
@@ -585,6 +660,10 @@ lcbvb_load_json(lcbvb_CONFIG *cfg, const char *data)
     /** Get the number of nodes. This traverses the list. Yuck */
     cfg->nsrv = cJSON_GetArraySize(jnodes);
 
+    if (network && *network == NULL) {
+        guess_network(jnodes, cfg->nsrv, source, network);
+    }
+
     /** Allocate a temporary one on the heap */
     cfg->servers = calloc(cfg->nsrv, sizeof(*cfg->servers));
     for (ii = 0; ii < cfg->nsrv; ii++) {
@@ -592,9 +671,15 @@ lcbvb_load_json(lcbvb_CONFIG *cfg, const char *data)
         cJSON *jsrv = cJSON_GetArrayItem(jnodes, ii);
 
         if (cfg->is3x) {
-            rv = build_server_3x(cfg, cfg->servers + ii, jsrv);
+            rv = build_server_3x(cfg, cfg->servers + ii, jsrv, network);
+            if (jnodes_defined && rv && ii >= jnodes_size) {
+                cfg->servers[ii].svc.data = 0;
+                cfg->servers[ii].svc_ssl.data = 0;
+                cfg->servers[ii].alt_svc.data = 0;
+                cfg->servers[ii].alt_svc_ssl.data = 0;
+            }
         } else {
-            rv = build_server_2x(cfg, cfg->servers + ii, jsrv);
+            rv = build_server_2x(cfg, cfg->servers + ii, jsrv, network);
         }
 
         if (!rv) {
@@ -638,6 +723,12 @@ lcbvb_load_json(lcbvb_CONFIG *cfg, const char *data)
     return -1;
 }
 
+int
+lcbvb_load_json(lcbvb_CONFIG *cfg, const char *data)
+{
+    return lcbvb_load_json_ex(cfg, data, NULL, NULL);
+}
+
 static void
 replace_hoststr(char **orig, const char *replacement)
 {
@@ -754,6 +845,9 @@ lcbvb_destroy(lcbvb_CONFIG *conf)
         free_service_strs(&srv->svc);
         free_service_strs(&srv->svc_ssl);
         free(srv->authority);
+        free(srv->alt_hostname);
+        free_service_strs(&srv->alt_svc);
+        free_service_strs(&srv->alt_svc_ssl);
     }
     free(conf->servers);
     free(conf->continuum);
@@ -783,6 +877,9 @@ svcs_to_json(lcbvb_SERVICES *svc, cJSON *jsvc, int is_ssl)
     EXTRACT_SERVICE("n1ql", n1ql);
     EXTRACT_SERVICE("indexScan", ixquery);
     EXTRACT_SERVICE("indexAdmin", ixadmin);
+    EXTRACT_SERVICE("fts", fts);
+    EXTRACT_SERVICE("cbas", cbas);
+
     #undef EXTRACT_SERVICE
 }
 
@@ -1139,12 +1236,41 @@ lcbvb_get_changetype(lcbvb_CONFIGDIFF *diff)
  ** String/Port Getters                                                      **
  ******************************************************************************
  ******************************************************************************/
+
+static const lcbvb_SERVICES *
+get_svc(const lcbvb_SERVER *srv, lcbvb_SVCMODE mode)
+{
+    if (srv->alt_hostname) {
+        if (mode == LCBVB_SVCMODE_PLAIN) {
+            return &srv->alt_svc;
+        } else {
+            return &srv->alt_svc_ssl;
+        }
+    } else {
+        if (mode == LCBVB_SVCMODE_PLAIN) {
+            return &srv->svc;
+        } else {
+            return &srv->svc_ssl;
+        }
+    }
+}
+
+static const char *
+get_hostname(const lcbvb_SERVER *srv)
+{
+    if (srv->alt_hostname) {
+        return srv->alt_hostname;
+    } else {
+        return srv->hostname;
+    }
+}
+
 LIBCOUCHBASE_API
 unsigned
 lcbvb_get_port(lcbvb_CONFIG *cfg,
     unsigned ix, lcbvb_SVCTYPE type, lcbvb_SVCMODE mode)
 {
-    lcbvb_SERVICES *svc;
+    const lcbvb_SERVICES *svc;
     lcbvb_SERVER *srv;
     if (type >= LCBVB_SVCTYPE__MAX || mode >= LCBVB_SVCMODE__MAX) {
         return 0;
@@ -1154,12 +1280,7 @@ lcbvb_get_port(lcbvb_CONFIG *cfg,
     }
 
     srv = cfg->servers + ix;
-
-    if (mode == LCBVB_SVCMODE_PLAIN) {
-        svc = &srv->svc;
-    } else {
-        svc = &srv->svc_ssl;
-    }
+    svc = get_svc(srv, mode);
 
     if (type == LCBVB_SVCTYPE_DATA) {
         return svc->data;
@@ -1197,17 +1318,13 @@ lcbvb_get_hostport(lcbvb_CONFIG *cfg,
     }
 
     srv = cfg->servers + ix;
-    if (mode == LCBVB_SVCMODE_PLAIN) {
-        svc = &srv->svc;
-    } else {
-        svc = &srv->svc_ssl;
-    }
+    svc = (lcbvb_SERVICES *)get_svc(srv, mode);
 
     strp = &svc->hoststrs[type];
     if (*strp == NULL) {
         size_t strn = strlen(srv->hostname) + 20;
         *strp = calloc(strn, sizeof(char));
-        copy_address(*strp, strn, srv->hostname, port);
+        copy_address(*strp, strn, get_hostname(srv), port);
     }
     return *strp;
 }
@@ -1217,7 +1334,7 @@ const char *
 lcbvb_get_hostname(const lcbvb_CONFIG *cfg, unsigned ix)
 {
     if (cfg->nsrv > ix) {
-        return cfg->servers[ix].hostname;
+        return get_hostname(cfg->servers + ix);
     } else {
         return NULL;
     }
@@ -1237,8 +1354,7 @@ lcbvb_get_randhost_ex(const lcbvb_CONFIG *cfg,
      */
     for (nn = 0; nn < cfg->nsrv; nn++) {
         const lcbvb_SERVER *server = cfg->servers + nn;
-        const lcbvb_SERVICES *svcs = mode == LCBVB_SVCMODE_PLAIN ?
-                &server->svc : &server->svc_ssl;
+        const lcbvb_SERVICES *svcs = get_svc(server, mode);
         int has_svc = 0;
 
         // Check if this node is in the exclude list
@@ -1299,11 +1415,10 @@ lcbvb_get_resturl(lcbvb_CONFIG *cfg, unsigned ix,
     srv = cfg->servers + ix;
     if (mode == LCBVB_SVCMODE_PLAIN) {
         prefix = "http";
-        svcs = &srv->svc;
     } else {
         prefix = "https";
-        svcs = &srv->svc_ssl;
     }
+    svcs = (lcbvb_SERVICES *)get_svc(srv, mode);
 
     if (svc == LCBVB_SVCTYPE_VIEWS) {
         path = srv->viewpath;
@@ -1326,11 +1441,12 @@ lcbvb_get_resturl(lcbvb_CONFIG *cfg, unsigned ix,
         return NULL;
     } else if (!*strp) {
         char buf[4096];
-        if (strchr(srv->hostname, ':')) {
+        const char *hostname = get_hostname(srv);
+        if (strchr(hostname, ':')) {
             // IPv6 and should be bracketed
-            snprintf(buf, sizeof(buf), "%s://[%s]:%d%s", prefix, srv->hostname, port, path);
+            snprintf(buf, sizeof(buf), "%s://[%s]:%d%s", prefix, hostname, port, path);
         } else {
-            snprintf(buf, sizeof(buf), "%s://%s:%d%s", prefix, srv->hostname, port, path);
+            snprintf(buf, sizeof(buf), "%s://%s:%d%s", prefix, hostname, port, path);
         }
         *strp = strdup(buf);
     }