asp.net mvc pdf viewer control : Merge pdf control software system web page winforms .net console mongodb_%20the%20definitive%20guide%20-%20kristina%20chodorow_140137-part1783

Figure 21-7. A plot of data accesses by age of data
Figure 21-8. The working set is data used in the requests before the cutoff of “frequent
requests”
You can also use MongoDB’s stats to estimate the working set. MongoDB keeps a map
of what it thinks is its memory, which you can see by passing in the "workingSet" :
1 option to serverStatus:
> db.adminCommand({"serverStatus" : 1"workingSet" : 1})
{
...
"workingSet" : {
"note" : "thisIsAnEstimate",
"pagesInMemory" : 18,
"computationTimeMicros" : 3685,
"overSeconds" : 2363
},
...
}
"pagesInMemory" is how many pages MongoDB thinks are currently in memory. Mon‐
goDB does not actually know how many pages are in memory, but it should be close. If
Calculating the Working Set | 349
Merge pdf - Merge, append PDF files in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Provide C# Demo Codes for Merging and Appending PDF Document
attach pdf to mail merge; scan multiple pages into one pdf
Merge pdf - VB.NET PDF File Merge Library: Merge, append PDF files in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
VB.NET Guide and Sample Codes to Merge PDF Documents in .NET Project
batch pdf merger online; adding pdf pages together
the number of pages returns equals the size of your RAM this it isn’t very helpful; but
if it is smaller it is probably about how large your working set is.
The "workingSet" field is not included in serverStatus’s output by default.
Some Working Set Examples
Suppose that you have a 40 GB working set. A total of 90% of requests hit the working
set, and 10% hit other data. If you have 500 GB of data and 50 GB of RAM, your working
set fits entirely in RAM. Once your application is has accessed the data it usually accesses
(a process called preheating), it should never have to go to disk again for the working
set. It had 10 GB of space for the 460 GB of less-frequently-accessed data. Obviously,
MongoDB will almost always have to go to disk for the nonworking set data.
On the other hand, suppose our working set does not fit in RAM. Say we have only 35
GB of RAM. Then the working set will generally take up most of RAM. The working
set has a higher probability of staying in RAM because it’s accessed more frequently, but
at some point the less-frequently-accessed data will have to be paged in, evicting working
set (or other less-frequently-accessed data). Thus, there is a constant churn back and
forth from disk: accessing the working set does not have predictable performance
anymore.
Tracking Performance
Performance of queries is often important to track and keep consistent. There are several
ways to track if MongoDB is having trouble with the current request load.
CPU is generally IO bound with MongoDB (IO wait is high, and the other metrics are
negligible). However, if user or system time is approaching 100% (or 100% multiplied
by the number of CPUs you have) the most common cause is that you’re missing an
index on a frequently-used query. The other possibility is that you are running a lot of
MapReduces or other server-side JavaScript. It is a good idea to track CPU (particularly
after deploying a new version of your application) to ensure that all your queries are
behaving as they should.
Note that the graph shown in Figure 21-9 is fine: if there is a low number of page faults,
IO wait may be dwarfed by other CPU activities. It is only when the other activities creep
up that bad indexes may be a culprit.
350 | Chapter 21: Monitoring MongoDB
Online Merge PDF files. Best free online merge PDF tool.
Online Merge PDF, Multiple PDF files into one. Download Free Trial. Merge PDF, Multiple PDF files. Drag and drop your PDF or several files in the box above.
apple merge pdf; c# merge pdf pages
C# WPF PDF Viewer SDK to view, annotate, convert and print PDF in
C#, C# convert PDF to HTML, C# convert PDF to Word, C# extract text from PDF, C# convert PDF to Jpeg, C# compress PDF, C# print PDF, C# merge PDF files, C# view
acrobat merge pdf files; best pdf combiner
Figure 21-9. A CPU with minimal IO wait. The top line is user and the lower line is
system. The other stats are very close to 0%.
A similar metric is queuing: how many request are waiting to be processed by MongoDB.
A request is considered queued when it is waiting for the lock it needs to do a read or
a write. Figure 21-10 shows a graph of read and write queues over time. No queues are
preferred (basically an empty graph), but this graph is nothing to be alarmed about. In
a busy system, it isn’t unusual for an operation to have to wait a bit for the correct lock
to be available.
Figure 21-10. Read and write queues over time
You can see if requests are piling up by looking at the number of requests enqueued.
Generally, queue size should be low. A large and ever-present queue is an indication
that mongod cannot keep up with its load. You should decrease the load on that server
as fast as possible.
You can correlate statistics about queuing with lock percentage: the amount of time
MongoDB spends locked. Often disk IO will throttle writes more than locking but
locking is still important to track, especially for systems with fast disks or many se‐
quential writes. Again, one of the most common causes of high lock percentage is that
you are missing an index. As lock percentage increases, operations on average have to
Tracking Performance | 351
VB.NET Create PDF from PowerPoint Library to convert pptx, ppt to
C#, C# convert PDF to HTML, C# convert PDF to Word, C# extract text from PDF, C# convert PDF to Jpeg, C# compress PDF, C# print PDF, C# merge PDF files, C# view
all jpg to one pdf converter; build pdf from multiple files
VB.NET Create PDF from Word Library to convert docx, doc to PDF in
C#, C# convert PDF to HTML, C# convert PDF to Word, C# extract text from PDF, C# convert PDF to Jpeg, C# compress PDF, C# print PDF, C# merge PDF files, C# view
asp.net merge pdf files; add pdf pages together
wait longer and longer for a lock. Thus, there is an unfortunate cascading nature to high
lock percentages making everything slower, causing requests to build up, causing more
load on the system and even higher lock percentages. Figure 21-11 shows an alarmingly
high lock percentage, which should be dealt with as soon as possible.
Lock percentage is often spiky depending on traffic levels; but if it trends upwards over
time it’s a good indication that your system is under stress and that something needs to
change. Thus, you should alert on lock percentage over a long time (so that a sudden
spike in traffic won’t trigger it).
On the other hand, you may want to also trigger an alert if lock percentage suddenly
spikes, say 25% over its normal value. This might be an indication that your system
cannot handle load spikes and that you may have to add capacity.
Figure 21-11. A lock percentage hovering worryingly near 100%
In addition to the global lock percentage, MongoDB tracks locking per database, so you
can see if you have a particular database with a lot of contention.
Tracking Free Space
One other metric that is basic but important to monitor is disk usage: track free disk
space. Sometimes users wait until their disk runs out of space before they think about
how they want to handle it. By monitoring your disk usage, you can predict how long
your current drive will be sufficient and plan in advance what to do when it is not.
As you run out of space, there are several options:
• If you are using sharding, add another shard.
• Shut down each member of a replica set (one at a time) and copy its data to a larger
disk, which can then be mounted. Restart the member and proceed to the next.
352 | Chapter 21: Monitoring MongoDB
VB.NET PDF- HTML5 PDF Viewer for VB.NET Project
C#, C# convert PDF to HTML, C# convert PDF to Word, C# extract text from PDF, C# convert PDF to Jpeg, C# compress PDF, C# print PDF, C# merge PDF files, C# view
split pdf into multiple files; combine pdf files
C# HTML5 PDF Viewer SDK to view PDF document online in C#.NET
C#, C# convert PDF to HTML, C# convert PDF to Word, C# extract text from PDF, C# convert PDF to Jpeg, C# compress PDF, C# print PDF, C# merge PDF files, C# view
batch merge pdf; pdf merger online
• Replace members of your replica set with members with a larger drive: remove an
old member and add a new member, and allow that one to catch up with the rest
of the set. Repeat for each member of the set.
• If you are using the directoryperdb option and you have a particularly fast-
growing database, move it to its own drive. Then mount the volume as a directory
in your data directory. This way the rest of your data doesn’t have to be moved.
Regardless of the technique you choose, plan ahead to minimize the impact on your
application. You need time to take backups, modify each member of your set in turn,
and copy your data from place to place.
Monitoring Replication
Replication lag and oplog length are important to track.
Lag is when the secondaries cannot keep up with the primary. Lag is calculated by
subtracting the time of the last op applied on a secondary from the time of the last op
on the primary. For example, if a secondary just applied an op with the timestamp
3:26:00 p.m. and the primary just applied an op with the timestamp 3:29:45 p.m., the
secondary is lagging by 3 minutes and 45 seconds. You want lag to be as close to 0 as
possible, and it is generally on the order of milliseconds. If a secondary is keeping up
with the primary, the replication lag should look something like the graph shown in
Figure 21-12: basically 0 all the time.
Figure 21-12. A replica set with no lag. This is what you want to see.
If a secondary cannot replicate writes as fast as the primary can write, you’ll start seeing
nonzero lag. The most extreme case of this is when replication is stuck: it cannot apply
any more operations for some reason. At this point, lag will grow by one second per
second, creating the steep slope shown in Figure 21-13. This could be caused by network
issues or a missing "_id" index, which is required on every collection for replication to
function properly.
Monitoring Replication | 353
C# PDF Image Extract Library: Select, copy, paste PDF images in C#
PDF ›› C# PDF: Extract PDF Image. How to C#: Extract Image from PDF Document. Support PDF Image Extraction from a Page, a Region on a Page, and PDF Document.
c# combine pdf; pdf mail merge
VB.NET PDF Text Extract Library: extract text content from PDF
PDF ›› VB.NET PDF: Extract PDF Text. VB.NET PDF - Extract Text from PDF Using VB. How to Extract Text from PDF with VB.NET Sample Codes in .NET Application.
add pdf files together; append pdf
If a collection is missing an "_id" index, take the server out of the replica set, start it as
a standalone server, and build the "_id" index. Make sure you create the "_id" index
as a unique index. Once created, the "_id" index cannot be dropped or changed (other
than by dropping the whole collection).
Figure 21-13. Replication getting stuck and, just before February 10, beginning to re‐
cover. The red lines are server restarts.
If a system is overloaded, a secondary may gradually fall behind. But you generally won’t
see the characteristic “one second per second” slope in the graph, but some replication
will still be happening. Still, it is important to be aware if the secondaries cannot keep
up with peak traffic or are gradually falling further behind.
Primaries do not throttle writes to “help” secondaries catch up, so it common for sec‐
ondaries to fall behind on overloaded systems (particularly as MongoDB tends to pri‐
oritize writes over reads, which means replication can be starved on the primary). You
can force throttling of the primary to some extent by using “w” with your write concern.
You also might want to try removing load from the secondary by routing any requests
it was handling to another member.
If you are on an extremely underloaded system you may see another interesting pattern:
sudden spikes in replication lag, as shown in Figure 21-14. The spikes shown are not
actually lag—they are caused by variations in sampling. The mongod is processing one
write every couple of minutes. Because lag is measured as the difference between time‐
stamps on the primary and secondary, measuring the timestamp of the secondary right
before a write on the primary makes it look minutes behind. If you increase the write
rate, these spikes should disappear.
354 | Chapter 21: Monitoring MongoDB
Figure 21-14. A low-write system can cause “phantom” lag
The other important metric to track is the length of each member’s oplog. Every member
that might become primary should have an oplog longer than a day. If a member may
be a sync source for another member, it should have an oplog longer than the time an
initial sync takes to complete. Figure 21-15 shows what a standard oplog-length graph
looks like. This oplog has an excellent length: 1,111 hours is over a month of data! In
general, oplogs should be as long as you can afford the disk space to make them. Given
the way they’re used, they take up basically no memory and a long oplog can mean the
difference between a painful ops experience and an easy one.
Figure 21-15. A typical oplog-length graph
Figure 21-16 shows a slightly unusual variation caused by a fairly short oplog and vari‐
able traffic. This is still healthy, but the oplog on that machine is probably too short
(between 6 and 11 hours of maintenance window). The administrator may want to make
the oplog longer when she gets a chance.
Monitoring Replication | 355
Figure 21-16. An oplog length of an application with daily traffic peaks
356 | Chapter 21: Monitoring MongoDB
CHAPTER 22
Making Backups
It is important to take regular backups of your system. Backups are good protection
against most types of failure, and very little can’t be solved by restoring from a clean
backup. This chapter covers the common options for taking backups:
• Single-server backups
• Special considerations for backing up replica sets
• How to back up a sharded cluster
Backups are only useful if you are confident about deploying them in an emergency.
Thus, for any backup technique you choose, be sure to practice both taking backups
and restoring from backups until you are comfortable with the restore procedure.
Backing Up a Server
There are a variety of ways of taking backups. Regardless of method, taking a backup
can cause strain on a system: it generally requires reading all your data into memory.
Thus, backups should generally be done on replica set secondaries (as opposed to the
primary) or, for standalone servers, at an off time.
The techniques in this section apply to any mongod, whether a standalone or a member
of a replica set, unless otherwise noted.
Filesystem Snapshot
The simplest way to make a backup is to take a filesystem snapshot. However, this
requires your filesystem to support snapshotting and you must be running mongod with
journaling enabled. If your system fulfills these two prerequisites, this method requires
no preparation: simply take a snapshot at any time.
357
To restore, ensure that mongod is not running. The exact command for restoring from
a snapshot varies by filesystem, but basically you restore the snapshot and then start
mongod. As you took a snapshot on a live system, the snapshot is essentially what the
data files would look like if mongod had been kill -9-ed at the time the snapshot was
taken. Thus, on startup, mongod will replay the journal files and then begin running
normally.
Copying Data Files
Another way of creating backups is to make a copy of everything in the data directory.
Because you cannot copy all of the files at the same moment without filesystem support,
you must prevent the data files from changing while you are making the copy. This can
be accomplished with a command called fsynclock:
> db.fsyncLock()
This command locks the database against any further writes and then flushes all dirty
data to disk (fsync), ensuring that the files in the data directory have the latest consistent
information and are not changing.
Once this command has been run, mongod will enqueue all incoming writes. It will not
process any further writes until it has been unlocked. Note that this command stops
writes to all databases (not just the one db is connected to).
Once the fsynclock command returns, copy all of the files in your data directory to a
backup location. On Linux, this can be done with a command such as:
$ cp -R /data/db/* /mnt/external-drive/backup
Make sure that you copy absolutely every file and folder from the data directory to the
backup location. Excluding files or directories may make the backup unusable or
corrupt.
Once you have finished copying the data, unlock the database to allow it to take writes
again:
> db.fsyncUnlock()
Your database will begin handling writes again normally.
Note that there are some locking issues with authentication and fsynclock. If you are
using authentication, do not close the shell between calling fsyncLock() and fsyncUn
lock(). If you disconnect, you may be unable to reconnect and have to restart mon
god. The fsyncLock() setting does not persist between restarts, mongod will always start
up unlocked.
358 | Chapter 22: Making Backups
Documents you may be interested
Documents you may be interested