OD is designed to deliver non-HTML cacheable objects (that is, objects that aren't text/html content type) under 100 MB in size.

In Bash you quite often need to check to see if a variable has been set or has a value other than an empty string. This can be done using the -n or -z string comparison operators.

select top 1 * from newsletters where IsActive = 1 order by PublishDate desc

// The search space within the array is changing for each round - but the list // is still the same size. Thus, k does not need to be updated with each round.

an hour

A European (again we see the y sound coming from a vowel)

They have a very simplistic view of the activity being monitored by only distilling it down into only a few dimensions for the rule to interrogate

UML automatically finds these hidden patterns to link seemingly unrelated accounts and customers. These links can be one of thousands of data fields that the UML model ingests.

SubscribePattern allows you to use a regex to specify topics of interest

The cache for consumers has a default maximum size of 64. If you expect to be handling more than (64 * number of executors) Kafka partitions, you can change this setting via spark.streaming.kafka.consumer.cache.maxCapacity.

Amazon integrated customer data and payment information with e-book distribution and its Amazon publishing initiative

Coding is not the fundamental skill

up vote 15 down vote This is one of the few reasons I like to use vim's mouse mode. If you use the GUI version, or your terminal supports sending drag events (such as xterm or rxvt-unicode) you can click on the split line and drag to resize the window exactly where you want, without a lot of guess work using the ctrl-w plus,minus,less,greater combinations. In terminal versions, you have to set mouse mode properly for this to work :set mouse=n (I use 'n', but 'a' also works) and you have to set the tty mouse type :set ttymouse=xterm2 A lot of people say that a lot of time is wasted using the mouse (mostly due to the time it takes to move your hand from the keyboard to the mouse and back), but I find that, in this case, the time saved by having immediate feedback while adjusting window sized and the quickness of re-resizing (keep movving the mouse instead of typing another key sequence) outweighs the delay of moingmy hand.

"What we think about is that there's a conversation, and inside of that conversation you have a contextual place where you can have all of the interactions that you want or have or need to have with a brand or service, and it can take multiple forms. It can be buttons, it can be UI [user interface] and it can be conversational when it needs to be," Marcus said.

gUiw Change current word to uppercase.

“throwing seniors under the bus” (to use the words of one senator) by keeping interest rates low.

real interest rates are determined by a wide range of economic factors, including prospects for economic growth—not by the Fed.

In distributed mode, you start many worker processes using the same group.id and they automatically coordinate to schedule execution of connectors and tasks across all available workers. I

Connectors and tasks are logical units of work and must be scheduled to execute in a process. Kafka Connect calls these processes workers and has two types of workers: standalone and distributed.

up vote 7 down vote accepted When you are starting your kafka broker you can define set of properties in conf/server.properties file. This file is just key value property file. One of the property is auto.create.topics.enable if it set tot true(by default) kafka will create topic automatically when you send message to non existing topic. All config options you can find here Imho Simple rule for creating topics is the following: number of replicas must be not less than number of nodes that you have. Number of topics must be the multiplier of number of node in your cluster for example: You have 9 node cluster your topic must have 9 partitions and 9 replicas or 18 partitions and 9 replicas or 36 partitions and 9 replicas and so on

The students who exerted more self-control were not more successful in accomplishing their goals. It was the students who experienced fewer temptations overall who were more successful when the researchers checked back in at the end of the semester.

ab -t 15 -k -T "application/vnd.kafka.binary.v1+json" -p postfile http://localhost:8082/topics/test

Owning stock gives you the right to vote in shareholder meetings, receive dividends (which are the company’s profits) if and when they are distributed, and it gives you the right to sell your shares to somebody else.

in sync replicas (ISRs) should be exactly equal to the total number of replicas.

Kafka metrics can be broken down into three categories:Kafka server (broker) metricsProducer metricsConsumer metrics

with notions of completeness being a convenient optimization rather than a semantic necessity.

"isr" is the set of "in-sync" replicas.

public void increment(String label, String topic) { + Stats.incr(label); + }

The component is pluggable, you can configure ingestion of metrics to any monitoring system by implementing MetricCollector interface. By default metrics are sent to Ostrich, statistic library bundled into secor.

We run Kafka on the old and trusty m1.xlarge

Shannon held up a BBC micro:bit board, which runs MicroPython and has been given to students in the UK, and noted that it only has 16KB of memory.

You measure the throughout that you can achieve on a single partition for production (call it p) and consumption (call it c). Let’s say your target throughput is t.

Messages are immediately written to the filesystem when they are received. Messages are not deleted when they are read but retained with some configurable SLA (say a few days or a week)

Clustered (Multi-Server) Setup

ZooKeeper snapshots can be one such a source of concurrent writes, and ideally should be written on a disk group separate from the transaction log.

If you do end up sharing the ensemble, you might want to use the chroot feature. With chroot, you give each application its own namespace.

Designing a High Level Consumer

the High Level Consumer is provided to abstract most of the details of consuming events from Kafka.

In merced, we used the low-level simple consumer and wrote our own work dispatcher to get precise control.

A better alternative is at least once message delivery. For at least once delivery, the consumer reads data from a partition, processes the message, and then commits the offset of the message it has processed. In this case, the consumer could crash between processing the message and committing the offset and when the consumer restarts it will process the message again. This leads to duplicate messages in downstream systems but no data loss.

no data loss will occur as long as producers and consumers handle this possibility and retry appropriately.

By electing a new leader as soon as possible messages may be dropped but we will minimized downtime as any new machine can be leader.

keep in mind that these guarantees hold as long as you are producing to one partition and consuming from one partition.

On every received heartbeat, the coordinator starts (or resets) a timer. If no heartbeat is received when the timer expires, the coordinator marks the member dead and signals the rest of the group that they should rejoin so that partitions can be reassigned. The duration of the timer is known as the session timeout and is configured on the client with the setting session.timeout.ms. 

The high watermark is the offset of the last message that was successfully copied to all of the log’s replicas.

Kafka scales topic consumption by distributing partitions among a consumer group, which is a set of consumers sharing a common group identifier.

In a recent analysis of more than 500 billion events collected from multiple global online services, 18% of user accounts that originated from cloud service IP ranges were fraudulent.

Kafka consumer offset management protocol to keep track of what’s been uploaded to S3

Data lost or corrupted at this stage isn’t recoverable so the greatest design objective for Secor is data integrity.

Replication is important for two primary reasons:

Sharding is important for two primary reasons:

, Elasticsearch provides the ability to subdivide your index into multiple pieces called shards.

An index can potentially store a large amount of data that can exceed the hardware limits of a single node. For example, a single index of a billion documents taking up 1TB of disk space may not fit on the disk of a single node or may be too slow to serve search requests from a single node alone.

The create index API allows to instantiate an index. Elasticsearch provides support for multiple indices, including executing operations across several indices.

incidents are an unavoidable reality of working with distributed systems, no matter how reliable. A prompt alerting solution should be an integral part of the design,

Consumers in this group are designed to be dead-simple, performant, and highly resilient. Since the data copied verbatim, no code upgrades are required to support new message types.

tar -zxvf target/secor-0.1-SNAPSHOT-bin.tar.gz -C ${SECOR_INSTALL_DIR}

More events may arrive late for various reasons, we need to handle late-arrived events consistently.

With Flume & FlumeNG, and a File channel, if you loose a broker node you will lose access to those events until you recover that disk.

Optimum buffer size is related to a number of things: file system block size, CPU cache size and cache latency. Most file systems are configured to use block sizes of 4096 or 8192. In theory, if you configure your buffer size so you are reading a few bytes more than the disk block, the operations with the file system can be extremely inefficient (i.e. if you configured your buffer to read 4100 bytes at a time, each read would require 2 block reads by the file system). If the blocks are already in cache, then you wind up paying the price of RAM -> L3/L2 cache latency. If you are unlucky and the blocks are not in cache yet, the you pay the price of the disk->RAM latency as well. This is why you see most buffers sized as a power of 2, and generally larger than (or equal to) the disk block size. This means that one of your stream reads could result in multiple disk block reads - but those reads will always use a full block - no wasted reads. Now, this is offset quite a bit in a typical streaming scenario because the block that is read from disk is going to still be in memory when you hit the next read (we are doing sequential reads here, after all) - so you wind up paying the RAM -> L3/L2 cache latency price on the next read, but not the disk->RAM latency. In terms of order of magnitude, disk->RAM latency is so slow that it pretty much swamps any other latency you might be dealing with. So, I suspect that if you ran a test with different cache sizes (haven't done this myself), you will probably find a big impact of cache size up to the size of the file system block. Above that, I suspect that things would level out pretty quickly. There are a ton of conditions and exceptions here - the complexities of the system are actually quite staggering (just getting a handle on L3 -> L2 cache transfers is mind bogglingly complex, and it changes with every CPU type). This leads to the 'real world' answer: If your app is like 99% out there, set the cache size to 8192 and move on (even better, choose encapsulation over performance and use BufferedInputStream to hide the details). If you are in the 1% of apps that are highly dependent on disk throughput, craft your implementation so you can swap out different disk interaction strategies, and provide the knobs and dials to allow your users to test and optimize (or come up with some self optimizing system).

The Kafka cluster retains all published records—whether or not they have been consumed—using a configurable retention period. For example, if the retention policy is set to two days, then for the two days after a record is published, it is available for consumption, after which it will be discarded to free up space. Kafka's performance is effectively constant with respect to data size so storing data for a long time is not a problem.

Kafka for Stream Processing

replication factor N, we will tolerate up to N-1 server failures without losing any records

Messages sent by a producer to a particular topic partition will be appended in the order they are sent. That is, if a record M1 is sent by the same producer as a record M2, and M1 is sent first, then M1 will have a lower offset than M2 and appear earlier in the log.

Consumers label themselves with a consumer group name, and each record published to a topic is delivered to one consumer instance within each subscribing consumer group. Consumer instances can be in separate processes or on separate machines.

The partitions of the log are distributed over the servers in the Kafka cluster with each server handling data and requests for a share of the partitions.

The first limitation is that each partition is physically represented as a directory of one or more segment files. So you will have at least one directory and several files per partition. Depending on your operating system and filesystem this will eventually become painful. However this is a per-node limit and is easily avoided by just adding more total nodes in the cluster.

the number of partitions -- there's no real "formula" other than this: you can have no more parallelism than you have partitions.

The offset the ordering of messages as an immutable sequence. Kafka maintains this message ordering for you.

So to a start up founder, timing correctly when to do something is far more important than doing that thing amazingly well

"I don't have a system and need to build one."

($20*3)-($20*3*.1) = $54

We should have built the absolute minimum and then manually maintained transactions through the backend if need be. To hell with formality. We were in the business of proving a hypothesis yet we acted as if it had already been proven.

the asteroid mining and the cultures that sprout up

Represents an object stored in Amazon S3.

S3ObjectInputStream

Listerine, for example, started life on the shelf as an antiseptic, sold as both floor cleaner and a treatment for gonorrhoea. But it wasn't a runaway success until it was marketed as a treatment for bad breath. 

But many ideas are destined for improvement

There are many people with good ideas who don't have the means, the will, or the courage to action them. Similarly, there are very talented business people who have no ideas, but are brilliant at the execution.

volume, velocity, and variety

replication-factor 3

For a topic with replication factor N, we will tolerate up to N-1 server failures without losing any records committed to the log.

The way consumption is implemented in Kafka is by dividing up the partitions in the log over the consumer instances so that each instance is the exclusive consumer of a "fair share" of partitions at any point in time. This process of maintaining membership in the group is handled by the Kafka protocol dynamically. If new instances join the group they will take over some partitions from other members of the group; if an instance dies, its partitions will be distributed to the remaining instances.

Consumers label themselves with a consumer group name

The producer is responsible for choosing which record to assign to which partition within the topic.

individual partition must fit on the servers that host it

the only metadata retained on a per-consumer basis is the offset or position of that consumer in the log. This offset is controlled by the consumer: normally a consumer will advance its offset linearly as it reads records, but, in fact, since the position is controlled by the consumer it can consume records in any order it likes.

the retention policy is set to two days, then for the two days after a record is published,

Executing the above code results in a TimeoutException:

The key idea of spark is Resilient Distributed Datasets (RDD); it supports in-memory processing computation.

But ideally, a client should have to know a single URI only; everything else – individual URIs, as well as recipes for constructing them e.g. in case of queries – should be communicated via hypermedia, as links within resource representations.

REST simply means using HTTP to expose some application functionality. The fundamental and most important operation (strictly speaking, “verb” or “method” would be a better term) is an HTTP GET.

HTTP fixes them at GET, PUT, POST and DELETE (primarily, at least), and casting all of your application semantics into just these four verbs takes some getting used to. But once you’ve done that, people start using a subset of what actually makes up REST – a sort of Web-based CRUD (Create, Read, Update, Delete) architecture. Applications that expose this anti-pattern are not really “unRESTful” (if there even is such a thing), they just fail to exploit another of REST’s core concepts: hypermedia as the engine of application state.