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
|
#ifndef CEPH_RGW_LOG_H
#define CEPH_RGW_LOG_H
#include "common/Formatter.h"
#include "common/OutputDataSocket.h"
#include "rgw_common.h"
class RGWRados;
struct rgw_log_entry {
string object_owner;
string bucket_owner;
string bucket;
utime_t time;
string remote_addr;
string user;
string obj;
string op;
string uri;
string http_status;
string error_code;
uint64_t bytes_sent;
uint64_t bytes_received;
uint64_t obj_size;
utime_t total_time;
string user_agent;
string referrer;
string bucket_id;
void encode(bufferlist &bl) const {
ENCODE_START(6, 5, bl);
::encode(object_owner, bl);
::encode(bucket_owner, bl);
::encode(bucket, bl);
::encode(time, bl);
::encode(remote_addr, bl);
::encode(user, bl);
::encode(obj, 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_FINISH(bl);
}
void decode(bufferlist::iterator &p) {
DECODE_START_LEGACY_COMPAT_LEN(6, 5, 5, p);
::decode(object_owner, p);
if (struct_v > 3)
::decode(bucket_owner, p);
::decode(bucket, p);
::decode(time, p);
::decode(remote_addr, p);
::decode(user, p);
::decode(obj, 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), "%llu", (long long)id);
bucket_id = buf;
} else {
::decode(bucket_id, p);
}
} else
bucket_id = "";
DECODE_FINISH(p);
}
void dump(Formatter *f) const;
static void generate_test_instances(list<rgw_log_entry*>& o);
};
WRITE_CLASS_ENCODER(rgw_log_entry)
struct rgw_intent_log_entry {
rgw_obj obj;
utime_t op_time;
uint32_t intent;
void encode(bufferlist &bl) const {
ENCODE_START(2, 2, bl);
::encode(obj, bl);
::encode(op_time, bl);
::encode(intent, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator &p) {
DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, p);
::decode(obj, p);
::decode(op_time, p);
::decode(intent, p);
DECODE_FINISH(p);
}
void dump(Formatter *f) const;
static void generate_test_instances(list<rgw_intent_log_entry*>& o);
};
WRITE_CLASS_ENCODER(rgw_intent_log_entry)
class OpsLogSocket : public OutputDataSocket {
Formatter *formatter;
void formatter_to_bl(bufferlist& bl);
protected:
void init_connection(bufferlist& bl);
public:
OpsLogSocket(CephContext *cct, uint64_t _backlog);
~OpsLogSocket();
void log(struct rgw_log_entry& entry);
};
int rgw_log_op(RGWRados *store, struct req_state *s, const string& op_name, OpsLogSocket *olog);
int rgw_log_intent(RGWRados *store, rgw_obj& obj, RGWIntentEvent intent, const utime_t& timestamp, bool utc);
int rgw_log_intent(RGWRados *store, struct req_state *s, rgw_obj& obj, RGWIntentEvent intent);
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
|
