1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_RGW_LOG_H
#define CEPH_RGW_LOG_H
#include <boost/container/flat_map.hpp>
#include "rgw_common.h"
#include "common/Formatter.h"
#include "common/OutputDataSocket.h"
class RGWRados;
struct rgw_log_entry {
using headers_map = boost::container::flat_map<std::string, std::string>;
using Clock = req_state::Clock;
rgw_user object_owner;
rgw_user bucket_owner;
string bucket;
Clock::time_point time;
string remote_addr;
string user;
rgw_obj_key obj;
string op;
string uri;
string http_status;
string error_code;
uint64_t bytes_sent;
uint64_t bytes_received;
uint64_t obj_size;
Clock::duration total_time;
string user_agent;
string referrer;
string bucket_id;
headers_map x_headers;
void encode(bufferlist &bl) const {
ENCODE_START(9, 5, bl);
encode(object_owner.id, bl);
encode(bucket_owner.id, bl);
encode(bucket, bl);
encode(time, bl);
encode(remote_addr, bl);
encode(user, bl);
encode(obj.name, bl);
encode(op, bl);
encode(uri, bl);
encode(http_status, bl);
encode(error_code, bl);
encode(bytes_sent, bl);
encode(obj_size, bl);
encode(total_time, bl);
encode(user_agent, bl);
encode(referrer, bl);
encode(bytes_received, bl);
encode(bucket_id, bl);
encode(obj, bl);
encode(object_owner, bl);
encode(bucket_owner, bl);
encode(x_headers, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator &p) {
DECODE_START_LEGACY_COMPAT_LEN(8, 5, 5, p);
decode(object_owner.id, p);
if (struct_v > 3)
decode(bucket_owner.id, p);
decode(bucket, p);
decode(time, p);
decode(remote_addr, p);
decode(user, p);
decode(obj.name, p);
decode(op, p);
decode(uri, p);
decode(http_status, p);
decode(error_code, p);
decode(bytes_sent, p);
decode(obj_size, p);
decode(total_time, p);
decode(user_agent, p);
decode(referrer, p);
if (struct_v >= 2)
decode(bytes_received, p);
else
bytes_received = 0;
if (struct_v >= 3) {
if (struct_v <= 5) {
uint64_t id;
decode(id, p);
char buf[32];
snprintf(buf, sizeof(buf), "%" PRIu64, id);
bucket_id = buf;
} else {
decode(bucket_id, p);
}
} else {
bucket_id = "";
}
if (struct_v >= 7) {
decode(obj, p);
}
if (struct_v >= 8) {
decode(object_owner, p);
decode(bucket_owner, p);
}
if (struct_v >= 9) {
decode(x_headers, p);
}
DECODE_FINISH(p);
}
void dump(Formatter *f) const;
static void generate_test_instances(list<rgw_log_entry*>& o);
};
WRITE_CLASS_ENCODER(rgw_log_entry)
class OpsLogSocket : public OutputDataSocket {
Formatter *formatter;
Mutex lock;
void formatter_to_bl(bufferlist& bl);
protected:
void init_connection(bufferlist& bl) override;
public:
OpsLogSocket(CephContext *cct, uint64_t _backlog);
~OpsLogSocket() override;
void log(struct rgw_log_entry& entry);
};
class RGWREST;
int rgw_log_op(RGWRados *store, RGWREST* const rest, struct req_state *s,
const string& op_name, OpsLogSocket *olog);
void rgw_log_usage_init(CephContext *cct, RGWRados *store);
void rgw_log_usage_finalize();
void rgw_format_ops_log_entry(struct rgw_log_entry& entry,
Formatter *formatter);
#endif /* CEPH_RGW_LOG_H */
|
