{ "setQueryCount", true, "bool", "set whether queries should be counted" },
{ "setQueryCountFilter", true, "func", "filter queries that would be counted, where `func` is a function with parameter `dq` which decides whether a query should and how it should be counted" },
{ "setRingBuffersLockRetries", true, "n", "set the number of attempts to get a non-blocking lock to a ringbuffer shard before blocking" },
+ { "setRingBuffersOptions", true, "{ lockRetries=int, recordQueries=true, recordResponses=true }", "set ringbuffer options" },
{ "setRingBuffersSize", true, "n [, numberOfShards]", "set the capacity of the ringbuffers used for live traffic inspection to `n`, and optionally the number of shards to use to `numberOfShards`" },
{ "setRoundRobinFailOnNoServer", true, "value", "By default the roundrobin load-balancing policy will still try to select a backend even if all backends are currently down. Setting this to true will make the policy fail and return that no server is available instead" },
{ "setRules", true, "list of rules", "replace the current rules with the supplied list of pairs of DNS Rules and DNS Actions (see `newRuleAction()`)" },
g_rings.setNumberOfLockRetries(retries);
});
+ luaCtx.writeFunction("setRingBuffersOptions", [](const LuaAssociativeTable<boost::variant<bool, uint64_t>>& options) {
+ setLuaSideEffect();
+ if (g_configurationDone) {
+ errlog("setRingBuffersOptions() cannot be used at runtime!");
+ g_outputBuffer = "setRingBuffersOptions() cannot be used at runtime!\n";
+ return;
+ }
+ if (options.count("lockRetries") > 0) {
+ auto retries = boost::get<uint64_t>(options.at("lockRetries"));
+ g_rings.setNumberOfLockRetries(retries);
+ }
+ if (options.count("recordQueries") > 0) {
+ auto record = boost::get<bool>(options.at("recordQueries"));
+ g_rings.setRecordQueries(record);
+ }
+ if (options.count("recordResponses") > 0) {
+ auto record = boost::get<bool>(options.at("recordResponses"));
+ g_rings.setRecordResponses(record);
+ }
+ });
+
luaCtx.writeFunction("setWHashedPertubation", [](uint64_t perturb) {
setLuaSideEffect();
checkParameterBound("setWHashedPertubation", perturb, std::numeric_limits<uint32_t>::max());
/* resize all the rings */
for (auto& shard : d_shards) {
shard = std::make_unique<Shard>();
- shard->queryRing.lock()->set_capacity(d_capacity / d_numberOfShards);
- shard->respRing.lock()->set_capacity(d_capacity / d_numberOfShards);
+ if (shouldRecordQueries()) {
+ shard->queryRing.lock()->set_capacity(d_capacity / d_numberOfShards);
+ }
+ if (shouldRecordResponses()) {
+ shard->respRing.lock()->set_capacity(d_capacity / d_numberOfShards);
+ }
}
/* we just recreated the shards so they are now empty */
}
}
+void Rings::setRecordQueries(bool record)
+{
+ d_recordQueries = record;
+}
+
+void Rings::setRecordResponses(bool record)
+{
+ d_recordResponses = record;
+}
+
size_t Rings::numDistinctRequestors()
{
std::set<ComboAddress, ComboAddress::addressOnlyLessThan> s;
void init();
void setNumberOfLockRetries(size_t retries);
+ void setRecordQueries(bool);
+ void setRecordResponses(bool);
size_t getNumberOfShards() const
{
only useful for debugging purposes */
size_t loadFromFile(const std::string& filepath, const struct timespec& now);
+ bool shouldRecordQueries() const
+ {
+ return d_recordQueries;
+ }
+
+ bool shouldRecordResponses() const
+ {
+ return d_recordResponses;
+ }
+
std::vector<std::unique_ptr<Shard> > d_shards;
pdns::stat_t d_blockingQueryInserts;
pdns::stat_t d_blockingResponseInserts;
size_t d_numberOfShards;
size_t d_nbLockTries = 5;
bool d_keepLockingStats{false};
+ bool d_recordQueries{true};
+ bool d_recordResponses{true};
};
extern Rings g_rings;
void handleResponseSent(const DNSName& qname, const QType& qtype, double udiff, const ComboAddress& client, const ComboAddress& backend, unsigned int size, const dnsheader& cleartextDH, dnsdist::Protocol outgoingProtocol, dnsdist::Protocol incomingProtocol)
{
- struct timespec ts;
- gettime(&ts);
- g_rings.insertResponse(ts, client, qname, qtype, static_cast<unsigned int>(udiff), size, cleartextDH, backend, outgoingProtocol);
+ if (g_rings.shouldRecordResponses()) {
+ struct timespec ts;
+ gettime(&ts);
+ g_rings.insertResponse(ts, client, qname, qtype, static_cast<unsigned int>(udiff), size, cleartextDH, backend, outgoingProtocol);
+ }
switch (cleartextDH.rcode) {
case RCode::NXDomain:
static bool applyRulesToQuery(LocalHolders& holders, DNSQuestion& dq, const struct timespec& now)
{
- g_rings.insertQuery(now, *dq.remote, *dq.qname, dq.qtype, dq.getData().size(), *dq.getHeader(), dq.getProtocol());
+ if (g_rings.shouldRecordQueries()) {
+ g_rings.insertQuery(now, *dq.remote, *dq.qname, dq.qtype, dq.getData().size(), *dq.getHeader(), dq.getProtocol());
+ }
if (g_qcount.enabled) {
string qname = (*dq.qname).toLogString();
d_config.remote.toStringWithPort(), getName(),
ids.qname.toLogString(), QType(ids.qtype).toString(), ids.origRemote.toStringWithPort());
- struct timespec ts;
- gettime(&ts);
+ if (g_rings.shouldRecordResponses()) {
+ struct timespec ts;
+ gettime(&ts);
- struct dnsheader fake;
- memset(&fake, 0, sizeof(fake));
- fake.id = ids.origID;
+ struct dnsheader fake;
+ memset(&fake, 0, sizeof(fake));
+ fake.id = ids.origID;
- g_rings.insertResponse(ts, ids.origRemote, ids.qname, ids.qtype, std::numeric_limits<unsigned int>::max(), 0, fake, d_config.remote, getProtocol());
+ g_rings.insertResponse(ts, ids.origRemote, ids.qname, ids.qtype, std::numeric_limits<unsigned int>::max(), 0, fake, d_config.remote, getProtocol());
+ }
}
void DownstreamState::handleTimeouts()
:param int num: The maximum number of attempts. Defaults to 5 if there is more than one shard, 0 otherwise.
+.. function:: setRingBuffersOptions(options)
+
+ .. versionadded:: 1.8.0
+
+ Set the rings buffers configuration
+
+ :param table options: A table with key: value pairs with options.
+
+ Options:
+
+ * ``lockRetries``: int - Set the number of shards to attempt to lock without blocking before giving up and simply blocking while waiting for the next shard to be available. Default to 5 if there is more than one shard, 0 otherwise
+ * ``recordQueries``: boolean - Whether to record queries in the ring buffers. Default is true. Note that :func:`grepq`, several top* commands (:func:`topClients`, :func:`topQueries`, ...) and the :doc:`Dynamic Blocks <../guides/dynblocks>` require this to be enabled.
+ * ``recordResponses``: boolean - Whether to record responses in the ring buffers. Default is true. Note that :func:`grepq`, several top* commands (:func:`topResponses`, :func:`topSlow`, ...) and the :doc:`Dynamic Blocks <../guides/dynblocks>` require this to be enabled.
+
.. function:: setRingBuffersSize(num [, numberOfShards])
.. versionchanged:: 1.6.0
projects / thirdparty / pdns.git / commitdiff
